Copyright (c) 2000, 2019 IBM Corporation and others.
This program and the accompanying materials
are made available under the terms of the Eclipse Public License 2.0
which accompanies this distribution, and is available at
https://www.eclipse.org/legal/epl-2.0/
SPDX-License-Identifier: EPL-2.0
Contributors:
    IBM Corporation - initial API and implementation
    IBM Corporation - added the following constants:
                                COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE
                                COMPILER_PB_STATIC_ACCESS_RECEIVER
                                COMPILER_TASK_TAGS
                                CORE_CIRCULAR_CLASSPATH
                                CORE_INCOMPLETE_CLASSPATH
    IBM Corporation - added run(IWorkspaceRunnable, IProgressMonitor)
    IBM Corporation - added exclusion patterns to source classpath entries
    IBM Corporation - added specific output location to source classpath entries
    IBM Corporation - added the following constants:
                                CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER
                                CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER
                                CLEAN
    IBM Corporation - added getClasspathContainerInitializer(String)
    IBM Corporation - added the following constants:
                                CODEASSIST_ARGUMENT_PREFIXES
                                CODEASSIST_ARGUMENT_SUFFIXES
                                CODEASSIST_FIELD_PREFIXES
                                CODEASSIST_FIELD_SUFFIXES
                                CODEASSIST_LOCAL_PREFIXES
                                CODEASSIST_LOCAL_SUFFIXES
                                CODEASSIST_STATIC_FIELD_PREFIXES
                                CODEASSIST_STATIC_FIELD_SUFFIXES
                                COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION
    IBM Corporation - added the following constants:
                                COMPILER_PB_LOCAL_VARIABLE_HIDING
                                COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD
                                COMPILER_PB_FIELD_HIDING
                                COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT
                                CORE_INCOMPATIBLE_JDK_LEVEL
                                VERSION_1_5
                                COMPILER_PB_EMPTY_STATEMENT
    IBM Corporation - added the following constants:
                                COMPILER_PB_INDIRECT_STATIC_ACCESS
                                COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION
                                COMPILER_PB_UNNECESSARY_CAST
    IBM Corporation - added the following constants:
                                COMPILER_PB_INVALID_JAVADOC
                                COMPILER_PB_INVALID_JAVADOC_TAGS
                                COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY
                                COMPILER_PB_MISSING_JAVADOC_TAGS
                                COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY
                                COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING
                                COMPILER_PB_MISSING_JAVADOC_COMMENTS
                                COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY
                                COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING
                                COMPILER_PB_DEPRECATION_WHEN_OVERRIDING_DEPRECATED_METHOD
                                COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING
    IBM Corporation - added the following constants:
                                TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC
    IBM Corporation - added the following constants:
                                COMPILER_PB_FALLTHROUGH_CASE
                                COMPILER_PB_PARAMETER_ASSIGNMENT
                                COMPILER_PB_NULL_REFERENCE
    IBM Corporation - added the following constants:
                                CODEASSIST_DEPRECATION_CHECK
    IBM Corporation - added the following constants:
                                COMPILER_PB_POTENTIAL_NULL_REFERENCE
                                COMPILER_PB_REDUNDANT_NULL_CHECK
    IBM Corporation - added the following constants:
                                COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE
    IBM Corporation - added the following constants:
                                COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE
    IBM Corporation - added the following constants:
                                COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION
							   COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_NO_TAG
							   COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_RETURN_TAG
							   COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_TAGS
    IBM Corporation - added the following constants:
                                COMPILER_PB_REDUNDANT_SUPERINTERFACE
    IBM Corporation - added the following constant:
                                COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE
    IBM Corporation - added getOptionForConfigurableSeverity(int)
    Benjamin Muskalla - added COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD
    Stephan Herrmann  - added COMPILER_PB_UNUSED_OBJECT_ALLOCATION
    Stephan Herrmann  - added COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS
    Stephan Herrmann  - added the following constants:
    								COMPILER_PB_UNCLOSED_CLOSEABLE,
    								COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE
    								COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE
    								COMPILER_ANNOTATION_NULL_ANALYSIS
    								COMPILER_NULLABLE_ANNOTATION_NAME
    								COMPILER_NONNULL_ANNOTATION_NAME
    								COMPILER_PB_NULL_SPECIFICATION_VIOLATION
    								COMPILER_PB_POTENTIAL_NULL_SPECIFICATION_VIOLATION
    								COMPILER_PB_NULL_SPECIFICATION_INSUFFICIENT_INFO
								COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT
								COMPILER_PB_SWITCH_MISSING_DEFAULT_CASE
								COMPILER_INHERIT_NULL_ANNOTATIONS
								COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED
								COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS
								COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE
								COMPILER_PB_UNLIKELY_EQUALS_ARGUMENT_TYPE
    Jesper S Moller   - Contributions for bug 381345 : [1.8] Take care of the Java 8 major version
                      - added the following constants:
								COMPILER_CODEGEN_METHOD_PARAMETERS_ATTR
    Harry Terkelsen (het@google.com) - Bug 449262 - Allow the use of third-party Java formatters
    Gábor Kövesdán - Contribution for Bug 350000 - [content assist] Include non-prefix matches in auto-complete suggestions
    Karsten Thoms - Bug 532505 - Reduce memory footprint of ClasspathAccessRule
    
/*******************************************************************************
 * Copyright (c) 2000, 2019 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE
 *                                 COMPILER_PB_STATIC_ACCESS_RECEIVER
 *                                 COMPILER_TASK_TAGS
 *                                 CORE_CIRCULAR_CLASSPATH
 *                                 CORE_INCOMPLETE_CLASSPATH
 *     IBM Corporation - added run(IWorkspaceRunnable, IProgressMonitor)
 *     IBM Corporation - added exclusion patterns to source classpath entries
 *     IBM Corporation - added specific output location to source classpath entries
 *     IBM Corporation - added the following constants:
 *                                 CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER
 *                                 CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER
 *                                 CLEAN
 *     IBM Corporation - added getClasspathContainerInitializer(String)
 *     IBM Corporation - added the following constants:
 *                                 CODEASSIST_ARGUMENT_PREFIXES
 *                                 CODEASSIST_ARGUMENT_SUFFIXES
 *                                 CODEASSIST_FIELD_PREFIXES
 *                                 CODEASSIST_FIELD_SUFFIXES
 *                                 CODEASSIST_LOCAL_PREFIXES
 *                                 CODEASSIST_LOCAL_SUFFIXES
 *                                 CODEASSIST_STATIC_FIELD_PREFIXES
 *                                 CODEASSIST_STATIC_FIELD_SUFFIXES
 *                                 COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_LOCAL_VARIABLE_HIDING
 *                                 COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD
 *                                 COMPILER_PB_FIELD_HIDING
 *                                 COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT
 *                                 CORE_INCOMPATIBLE_JDK_LEVEL
 *                                 VERSION_1_5
 *                                 COMPILER_PB_EMPTY_STATEMENT
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_INDIRECT_STATIC_ACCESS
 *                                 COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION
 *                                 COMPILER_PB_UNNECESSARY_CAST
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_INVALID_JAVADOC
 *                                 COMPILER_PB_INVALID_JAVADOC_TAGS
 *                                 COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY
 *                                 COMPILER_PB_MISSING_JAVADOC_TAGS
 *                                 COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY
 *                                 COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING
 *                                 COMPILER_PB_MISSING_JAVADOC_COMMENTS
 *                                 COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY
 *                                 COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING
 *                                 COMPILER_PB_DEPRECATION_WHEN_OVERRIDING_DEPRECATED_METHOD
 *                                 COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING
 *     IBM Corporation - added the following constants:
 *                                 TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_FALLTHROUGH_CASE
 *                                 COMPILER_PB_PARAMETER_ASSIGNMENT
 *                                 COMPILER_PB_NULL_REFERENCE
 *     IBM Corporation - added the following constants:
 *                                 CODEASSIST_DEPRECATION_CHECK
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_POTENTIAL_NULL_REFERENCE
 *                                 COMPILER_PB_REDUNDANT_NULL_CHECK
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION
 *								   COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_NO_TAG
 *								   COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_RETURN_TAG
 *								   COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_TAGS
 *     IBM Corporation - added the following constants:
 *                                 COMPILER_PB_REDUNDANT_SUPERINTERFACE
 *     IBM Corporation - added the following constant:
 *                                 COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE
 *     IBM Corporation - added getOptionForConfigurableSeverity(int)
 *     Benjamin Muskalla - added COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD
 *     Stephan Herrmann  - added COMPILER_PB_UNUSED_OBJECT_ALLOCATION
 *     Stephan Herrmann  - added COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS
 *     Stephan Herrmann  - added the following constants:
 *     								COMPILER_PB_UNCLOSED_CLOSEABLE,
 *     								COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE
 *     								COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE
 *     								COMPILER_ANNOTATION_NULL_ANALYSIS
 *     								COMPILER_NULLABLE_ANNOTATION_NAME
 *     								COMPILER_NONNULL_ANNOTATION_NAME
 *     								COMPILER_PB_NULL_SPECIFICATION_VIOLATION
 *     								COMPILER_PB_POTENTIAL_NULL_SPECIFICATION_VIOLATION
 *     								COMPILER_PB_NULL_SPECIFICATION_INSUFFICIENT_INFO
 *									COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT
 *									COMPILER_PB_SWITCH_MISSING_DEFAULT_CASE
 *									COMPILER_INHERIT_NULL_ANNOTATIONS
 *									COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED
 *									COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS
 *									COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE
 *									COMPILER_PB_UNLIKELY_EQUALS_ARGUMENT_TYPE
 *     Jesper S Moller   - Contributions for bug 381345 : [1.8] Take care of the Java 8 major version
 *                       - added the following constants:
 *									COMPILER_CODEGEN_METHOD_PARAMETERS_ATTR
 *     Harry Terkelsen (het@google.com) - Bug 449262 - Allow the use of third-party Java formatters
 *     Gábor Kövesdán - Contribution for Bug 350000 - [content assist] Include non-prefix matches in auto-complete suggestions
 *     Karsten Thoms - Bug 532505 - Reduce memory footprint of ClasspathAccessRule
 *     
 *******************************************************************************/

package org.eclipse.jdt.core;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.zip.ZipFile;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.core.search.TypeNameRequestor;
import org.eclipse.jdt.core.util.IAttributeNamesConstants;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
import org.eclipse.jdt.internal.compiler.env.AutomaticModuleNaming;
import org.eclipse.jdt.internal.compiler.env.IModule;
import org.eclipse.jdt.internal.compiler.env.IModule.IModuleReference;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.core.BatchOperation;
import org.eclipse.jdt.internal.core.BufferManager;
import org.eclipse.jdt.internal.core.ClasspathAttribute;
import org.eclipse.jdt.internal.core.ClasspathEntry;
import org.eclipse.jdt.internal.core.ClasspathValidation;
import org.eclipse.jdt.internal.core.CreateTypeHierarchyOperation;
import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
import org.eclipse.jdt.internal.core.ExternalFoldersManager;
import org.eclipse.jdt.internal.core.JavaCorePreferenceInitializer;
import org.eclipse.jdt.internal.core.JavaModel;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.core.PackageFragmentRoot;
import org.eclipse.jdt.internal.core.Region;
import org.eclipse.jdt.internal.core.SetContainerOperation;
import org.eclipse.jdt.internal.core.SetVariablesOperation;
import org.eclipse.jdt.internal.core.builder.JavaBuilder;
import org.eclipse.jdt.internal.core.builder.ModuleInfoBuilder;
import org.eclipse.jdt.internal.core.builder.State;
import org.eclipse.jdt.internal.core.nd.indexer.Indexer;
import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
import org.eclipse.jdt.internal.core.util.MementoTokenizer;
import org.eclipse.jdt.internal.core.util.Messages;
import org.eclipse.jdt.internal.core.util.ModuleUtil;
import org.eclipse.jdt.internal.core.util.Util;
import org.osgi.framework.BundleContext;

The plug-in runtime class for the Java model plug-in containing the core
(UI-free) support for Java projects.

Like all plug-in runtime classes (subclasses of Plugin), this
class is automatically instantiated by the platform when the plug-in gets
activated. Clients must not attempt to instantiate plug-in runtime classes
directly.


The single instance of this class can be accessed from any plug-in declaring
the Java model plug-in as a prerequisite via
JavaCore.getJavaCore(). The Java model plug-in will be activated
automatically if not already active.

@noinstantiate
This class is not intended to be instantiated by clients./**
 * The plug-in runtime class for the Java model plug-in containing the core
 * (UI-free) support for Java projects.
 * <p>
 * Like all plug-in runtime classes (subclasses of <code>Plugin</code>), this
 * class is automatically instantiated by the platform when the plug-in gets
 * activated. Clients must not attempt to instantiate plug-in runtime classes
 * directly.
 * </p>
 * <p>
 * The single instance of this class can be accessed from any plug-in declaring
 * the Java model plug-in as a prerequisite via
 * <code>JavaCore.getJavaCore()</code>. The Java model plug-in will be activated
 * automatically if not already active.
 * </p>
 * @noinstantiate This class is not intended to be instantiated by clients.
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public final class JavaCore extends Plugin {

	private static final IResource[] NO_GENERATED_RESOURCES = new IResource[0];

	private static Plugin JAVA_CORE_PLUGIN = null;
	
The plug-in identifier of the Java core support
(value "org.eclipse.jdt.core").
/**
	 * The plug-in identifier of the Java core support
	 * (value <code>"org.eclipse.jdt.core"</code>).
	 */
	public static final String PLUGIN_ID = "org.eclipse.jdt.core" ; //$NON-NLS-1$

	
The identifier for the Java builder
(value "org.eclipse.jdt.core.javabuilder").
/**
	 * The identifier for the Java builder
	 * (value <code>"org.eclipse.jdt.core.javabuilder"</code>).
	 */
	public static final String BUILDER_ID = PLUGIN_ID + ".javabuilder" ; //$NON-NLS-1$

	
The identifier for the Java model
(value "org.eclipse.jdt.core.javamodel").
/**
	 * The identifier for the Java model
	 * (value <code>"org.eclipse.jdt.core.javamodel"</code>).
	 */
	public static final String MODEL_ID = PLUGIN_ID + ".javamodel" ; //$NON-NLS-1$

	
The identifier for the Java nature
(value "org.eclipse.jdt.core.javanature").
The presence of this nature on a project indicates that it is
Java-capable.
See Also:
hasNature.hasNature(String)/**
	 * The identifier for the Java nature
	 * (value <code>"org.eclipse.jdt.core.javanature"</code>).
	 * The presence of this nature on a project indicates that it is
	 * Java-capable.
	 *
	 * @see org.eclipse.core.resources.IProject#hasNature(java.lang.String)
	 */
	public static final String NATURE_ID = PLUGIN_ID + ".javanature" ; //$NON-NLS-1$

	
Name of the handle id attribute in a Java marker.
/**
	 * Name of the handle id attribute in a Java marker.
	 */
	protected static final String ATT_HANDLE_ID =
		"org.eclipse.jdt.internal.core.JavaModelManager.handleId" ; //$NON-NLS-1$

	
Name of the User Library Container id.
Since:
3.0/**
	 * Name of the User Library Container id.
	 * @since 3.0
	 */
	public static final String USER_LIBRARY_CONTAINER_ID= "org.eclipse.jdt.USER_LIBRARY"; //$NON-NLS-1$

	
Since:
3.14/**
	 * @since 3.14
	 */
	public static final String MODULE_PATH_CONTAINER_ID = "org.eclipse.jdt.MODULE_PATH"; //$NON-NLS-1$

	// Begin configurable option IDs {

	
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).

Option id:
"org.eclipse.jdt.core.compiler.debug.localVariable"
Possible values:
{ "generate", "do not generate" }
Default:
"generate"

@category
CompilerOptionID/**
	 * Compiler option ID: Generating Local Variable Debug Attribute.
	 * <p>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).</p>
	 * <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$
	
Compiler option ID: 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"

@category
CompilerOptionID/**
	 * Compiler option ID: Generating Line Number Debug Attribute.
	 * <p>When generated, this attribute will enable source code highlighting in debugger
	 *    (.class file is then bigger).</p>
	 * <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$
	
Compiler option ID: 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"

@category
CompilerOptionID/**
	 * Compiler option ID: Generating Source Debug Attribute.
	 * <p>When generated, this attribute will enable the debugger to present the
	 *    corresponding source code.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.codegen.unusedLocal"
Possible values:
{ "preserve", "optimize out" }
Default:
"preserve"

@category
CompilerOptionID/**
	 * Compiler option ID: Preserving Unused Local Variables.
	 * <p>Unless requested to preserve unused local variables (that is, never read), the
	 *    compiler will optimize them out, potentially altering debugging.</p>
	 * <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$
	
Compiler option ID: Generating Method Parameters Attribute.
When generated, this attribute will enable information about the formal parameters of a method
(such as their names) to be accessed from reflection libraries, annotation processing,
code weaving, and in the debugger, from platform target level 1.8 and later.

Option id:
"org.eclipse.jdt.core.compiler.codegen.methodParameters"
Possible values:
{ "generate", "do not generate" }
Default:
"do not generate"

Since:
3.10
@category
CompilerOptionID/**
	 * Compiler option ID: Generating Method Parameters Attribute.
	 * <p>When generated, this attribute will enable information about the formal parameters of a method
	 * (such as their names) to be accessed from reflection libraries, annotation processing,
	 * code weaving, and in the debugger, from platform target level 1.8 and later.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.methodParameters"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "generate", "do not generate" }</code></dd>
	 * <dt>Default:</dt><dd><code>"do not generate"</code></dd>
	 * </dl>
	 * @since 3.10
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_CODEGEN_METHOD_PARAMETERS_ATTR = PLUGIN_ID + ".compiler.codegen.methodParameters"; //$NON-NLS-1$
	
Compiler option ID: Defining Target Java Platform.
For binary compatibility reasons, .class files are tagged with a minimal required VM version.
Note that "1.4" and higher target versions require the compliance mode to be at least as high
   as the target version. Usually, compliance, target, and source versions are set to the same values.
"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", "cldc1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "9", "10", "11" }
Default:
"1.2"

See Also:
COMPILER_COMPLIANCE
COMPILER_SOURCE
setComplianceOptions(String, Map)
@category
CompilerOptionID/**
	 * Compiler option ID: Defining Target Java Platform.
	 * <p>For binary compatibility reasons, .class files are tagged with a minimal required VM version.</p>
	 * <p>Note that <code>"1.4"</code> and higher target versions require the compliance mode to be at least as high
	 *    as the target version. Usually, compliance, target, and source versions are set to the same values.</p>
	 * <p><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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.targetPlatform"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "1.1", "cldc1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "9", "10", "11" }</code></dd>
	 * <dt>Default:</dt><dd><code>"1.2"</code></dd>
	 * </dl>
	 * @category CompilerOptionID
	 * @see #COMPILER_COMPLIANCE
	 * @see #COMPILER_SOURCE
	 * @see #setComplianceOptions(String, Map)
	 */
	public static final String COMPILER_CODEGEN_TARGET_PLATFORM = PLUGIN_ID + ".compiler.codegen.targetPlatform"; //$NON-NLS-1$
	
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 COMPILER_CODEGEN_TARGET_PLATFORM).

Option id:
"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Inline JSR Bytecode Instruction.
	 * <p>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.</p>
	 * <p>This mode is anticipating support for the Java Specification Request 202.</p>
	 * <p>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}).</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.doc.comment.support"
Possible values:
{ "enabled", "disabled" }
Default:
"enabled"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Javadoc Comment Support.
	 * <p>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.</p>
	 * <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$
	
Deprecated:
Discontinued since turning off would violate language specs.
@category
DeprecatedOptionID/**
	 * @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$
	
Deprecated:
Discontinued since turning off would violate language specs.
@category
DeprecatedOptionID/**
	 * @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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Attempt to Override Package Visible Method.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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
   scenario either as an error or a warning.

Option id:
"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Method With Constructor Name.
	 * <p>Naming a method with a constructor name is generally considered poor
	 *    style programming. When enabling this option, the compiler will signal such
	 *    scenario either as an error or a warning.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"warning"

@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Deprecation.
	 * <p>When enabled, the compiler will signal use of deprecated API either as an
	 *    error or a warning.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Reporting Terminal Deprecation.
When enabled, the compiler will signal use of terminally deprecated API either as an
   error or a warning.

Option id:
"org.eclipse.jdt.core.compiler.problem.terminalDeprecation"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.14
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Terminal Deprecation.
	 * <p>When enabled, the compiler will signal use of terminally deprecated API either as an
	 *    error or a warning.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.terminalDeprecation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.14
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_TERMINAL_DEPRECATION = PLUGIN_ID + ".compiler.problem.terminalDeprecation"; //$NON-NLS-1$
	
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 COMPILER_PB_DEPRECATION.

Option id:
"org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Deprecation Inside Deprecated Code.
	 * <p>When enabled, the compiler will signal use of deprecated API inside deprecated code.</p>
	 * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}.</p>
	 * <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$
	
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 COMPILER_PB_DEPRECATION.

Option id:
"org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Deprecation When Overriding Deprecated Method.
	 * <p>When enabled, the compiler will signal the declaration of a method overriding a deprecated one.</p>
	 * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}.</p>
	 * <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$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"warning"

@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Hidden Catch Block.
	 * <p>Locally to a try statement, some catch blocks may hide others. For example,</p>
	 *    <pre>
	 *      try {  throw new java.io.CharConversionException();
	 *      } catch (java.io.CharConversionException e) {
	 *      } catch (java.io.IOException e) {}.
	 *    </pre>
	 * <p>When enabling this option, the compiler will issue an error or a warning for hidden
	 *    catch blocks corresponding to checked exceptions.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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).

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedLocal"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Local.
	 * <p>When enabled, the compiler will issue an error or a warning for unused local
	 *    variables (that is, variables never read from).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLocal"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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).

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedParameter"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Parameter.
	 * <p>When enabled, the compiler will issue an error or a warning for unused method
	 *    parameters (that is, parameters never read from).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameter"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Reporting Unused Exception Parameter.
When enabled, the compiler will issue an error or a warning for unused exception
   parameters (that is, the thrown exception is never read from).

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

@category
CompilerOptionID
Since:
3.11/**
	 * Compiler option ID: Reporting Unused Exception Parameter.
	 * <p>When enabled, the compiler will issue an error or a warning for unused exception
	 *    parameters (that is, the thrown exception is never read from).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @category CompilerOptionID
	 * @since 3.11
	 */
	public static final String COMPILER_PB_UNUSED_EXCEPTION_PARAMETER = PLUGIN_ID + ".compiler.problem.unusedExceptionParameter"; //$NON-NLS-1$
	
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 COMPILER_PB_UNUSED_PARAMETER.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Parameter if Implementing Abstract Method.
	 * <p>When enabled, the compiler will signal unused parameters in abstract method implementations.</p>
	 * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}.</p>
	 * <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$
	
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 COMPILER_PB_UNUSED_PARAMETER.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Parameter if Overriding Concrete Method.
	 * <p>When enabled, the compiler will signal unused parameters in methods overriding concrete ones.</p>
	 * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}.</p>
	 * <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$
	
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. @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 COMPILER_PB_UNUSED_PARAMETER.
Note: this option has no effect until the doc comment support is enabled according to the option COMPILER_DOC_COMMENT_SUPPORT.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference"
Possible values:
{ "enabled", "disabled" }
Default:
"enabled"

Since:
3.3
@category
CompilerOptionID/**
	 * Compiler option ID: Consider Reference in Doc Comment for Unused Parameter Check.
	 * <p>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.</p>
	 * <p>The severity of the unused parameter problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}.</p>
	 * <p>Note: this option has no effect until the doc comment support is enabled according to the
	 *    option {@link #COMPILER_DOC_COMMENT_SUPPORT}.</p>
	 * <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$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"warning"

Since:
2.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Import.
	 * <p>When enabled, the compiler will issue an error or a warning for unused import
	 *    reference.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedImport"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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 "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", "info", "ignore" }
Default:
"warning"

Since:
3.4
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Presence of Type Arguments for a Non-Generic Method Invocation.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Synthetic Access Emulation.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$

	
Compiler option ID: Reporting Unused Type Parameter.
When enabled, the compiler will issue an error or a warning whenever it encounters an 
unused type parameter. 

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedTypeParameter"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.9
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Type Parameter.
	 * <p>When enabled, the compiler will issue an error or a warning whenever it encounters an 
	 * unused type parameter. </p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedTypeParameter"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.9
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNUSED_TYPE_PARAMETER = PLUGIN_ID + ".compiler.problem.unusedTypeParameter"; //$NON-NLS-1$

	
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 //$NON-NLS-<n>$).

Option id:
"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
2.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Non-Externalized String Literal.
	 * <p>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>).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"warning"

Since:
2.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Usage of <code>'assert'</code> Identifier.
	 * <p>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).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.assertIdentifier"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Usage of <code>'enum'</code> Identifier.
	 * <p>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).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.enumIdentifier"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Non-Static Reference to a Static Member.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Indirect Reference to a Static Member.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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 'x = x').

Option id:
"org.eclipse.jdt.core.compiler.problem.noEffectAssignment"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Assignment with no Effect.
	 * <p>When enabled, the compiler will issue an error or a warning whenever an assignment
	 *    has no effect (e.g <code>'x = x'</code>).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.noEffectAssignment"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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 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", "info", "ignore" }
Default:
"warning"

Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Interface Method not Compatible with non-Inherited Methods.
	 * <p>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,</p>
	 *    <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", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Private Members.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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).

Option id:
"org.eclipse.jdt.core.compiler.problem.localVariableHiding"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Local Variable Declaration Hiding another Variable.
	 * <p>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).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.localVariableHiding"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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 COMPILER_PB_LOCAL_VARIABLE_HIDING.

Option id:
"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Special Parameter Hiding another Field.
	 * <p>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).</p>
	 * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_LOCAL_VARIABLE_HIDING}.</p>
	 * <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$
	
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).

Option id:
"org.eclipse.jdt.core.compiler.problem.fieldHiding"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Field Declaration Hiding another Variable.
	 * <p>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).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fieldHiding"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.typeParameterHiding"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Type Declaration Hiding another Type.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.typeParameterHiding"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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).

Option id:
"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Possible Accidental Boolean Assignment.
	 * <p>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).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.fallthroughCase"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.2
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Switch Fall-Through Case.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fallthroughCase"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.emptyStatement"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Empty Statements and Unnecessary Semicolons.
	 * <p>When enabled, the compiler will issue an error or a warning if an empty statement or a
	 *    unnecessary semicolon is encountered.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.emptyStatement"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID.

Option id:
"org.eclipse.jdt.core.compiler.problem.booleanMethodThrowingException"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID
Deprecated:
- this option has no effect/**
	 * 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", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.0
	 * @category CompilerOptionID
	 * @deprecated - this option has no effect
	 */
	public static final String COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION = PLUGIN_ID + ".compiler.problem.booleanMethodThrowingException"; //$NON-NLS-1$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unnecessary Type Check.
	 * <p>When enabled, the compiler will issue an error or a warning when a cast or an <code>instanceof</code> operation
	 *    is unnecessary.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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 else clause (in situation where then clause is not completing normally).

Option id:
"org.eclipse.jdt.core.compiler.problem.unnecessaryElse"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unnecessary Else.
	 * <p>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).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryElse"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Undocumented Empty Block.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Finally Blocks Not Completing Normally.
	 * <p>When enabled, the compiler will issue an error or a warning when a finally block does not complete normally.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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 checked exception as thrown,
   but its body actually raises neither that exception, nor any other
   exception extending it.
This diagnostic is further tuned by options COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE, COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE, and COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Declared Thrown Exception.
	 * <p>When enabled, the compiler will issue an error or a warning when a
	 *    method or a constructor is declaring a checked exception as thrown,
	 *    but its body actually raises neither that exception, nor any other
	 *    exception extending it.</p>
	 * <p>This diagnostic is further tuned by options
	 *    {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE},
	 *    {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE},
	 *    and {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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 unused declared thrown exception problem is controlled with option COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION.
This diagnostic is further tuned by options COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE and COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Declared Thrown Exception in Overriding Method.
	 * <p>When disabled, the compiler will report unused declared thrown
	 *    exceptions neither on overriding methods nor on implementing methods.</p>
	 * <p>The severity of the unused declared thrown exception problem is
	 *    controlled with option {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.</p>
	 * <p>This diagnostic is further tuned by options
	 *    {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE} and
	 *    {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE}.</p>
	 * <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$
	
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. @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 COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION.
Note: this option has no effect until the doc comment support is enabled according to the option COMPILER_DOC_COMMENT_SUPPORT.
This diagnostic is further tuned by options COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE and COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"
Possible values:
{ "enabled", "disabled" }
Default:
"enabled"

Since:
3.4
@category
CompilerOptionID/**
	 * Compiler option ID: Consider Reference in Doc Comment for Unused Declared Thrown Exception Check.
	 * <p>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.</p>
	 * <p>The severity of the unused declared thrown exception problem is controlled with option {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.</p>
	 * <p>Note: this option has no effect until the doc comment support is enabled according to the
	 *    option {@link #COMPILER_DOC_COMMENT_SUPPORT}.</p>
	 * <p>This diagnostic is further tuned by options
	 *    {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE}
	 *    and {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.</p>
	 * <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$
	
Compiler option ID: Reporting Unused Declared Thrown Exception Exempts Exception And Throwable.
When enabled, the compiler will issue an error or a warning when a method or a constructor is declaring a checked exception else than Throwable or Exception as thrown, but its body actually raises neither that exception, nor any other exception extending it. When disabled, the compiler will issue an error or a warning when a method or a constructor is declaring a checked exception (including Throwable and Exception) as thrown, but its body actually raises neither that exception, nor any other exception extending it.
The severity of the unused declared thrown exception problem is controlled with option COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION.
This diagnostic is further tuned by options COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE and COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable"
Possible values:
{ "enabled", "disabled" }
Default:
"enabled"

Since:
3.4
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unused Declared Thrown Exception Exempts Exception And Throwable.
	 * <p>When enabled, the compiler will issue an error or a warning when a
	 *    method or a constructor is declaring a checked exception else than
	 *    {@link java.lang.Throwable} or {@link java.lang.Exception} as thrown,
	 *    but its body actually raises neither that exception, nor any other
	 *    exception extending it. When disabled, the compiler will issue an
	 *    error or a warning when a method or a constructor is declaring a
	 *    checked exception (including {@link java.lang.Throwable} and
	 *    {@link java.lang.Exception}) as thrown, but its body actually raises
	 *    neither that exception, nor any other exception extending it.</p>
	 * <p>The severity of the unused declared thrown exception problem is
	 *    controlled with option
	 *    {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.</p>
	 * <p>This diagnostic is further tuned by options
	 *    {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE}
	 *    and {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable"</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_EXEMPT_EXCEPTION_AND_THROWABLE = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable"; //$NON-NLS-1$
	
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. 'x' should rather be written 'this.x'.

Option id:
"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unqualified Access to Field.
	 * <p>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>.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Deprecated:
Use COMPILER_PB_UNCHECKED_TYPE_OPERATION instead.
Since:
3.1
@category
DeprecatedOptionID/**
	 * @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$
	
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 #foo(X<String>) with arguments (X)).

Option id:
"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unchecked Type Operation.
	 * <p>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>).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.rawTypeReference"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.2
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Raw Type Reference.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.rawTypeReference"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Reporting of Unavoidable Generic Type Problems due to raw APIs.
 When enabled, the compiler will issue an error or warning even when it detects a generics-related type problem
    that could not have been avoided by the programmer, because a referenced API already contains raw types.
    As an example, a type may be forced to use raw types
    in its method signatures and return types because the methods it overrides from a super type are declared to
    use raw types in the first place.

Option id:
"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems"
Possible values:
{ "enabled", "disabled" }
Default:
"enabled"

Since:
3.7
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting of Unavoidable Generic Type Problems due to raw APIs.
	 * <p> When enabled, the compiler will issue an error or warning even when it detects a generics-related type problem
	 *     that could not have been avoided by the programmer, because a referenced API already contains raw types.
	 *     As an example, a type may be forced to use raw types
	 *     in its method signatures and return types because the methods it overrides from a super type are declared to
	 *     use raw types in the first place.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNAVOIDABLE_GENERIC_TYPE_PROBLEMS = PLUGIN_ID + ".compiler.problem.unavoidableGenericTypeProblems"; //$NON-NLS-1$

	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.finalParameterBound"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting final Bound for Type Parameter.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.finalParameterBound"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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 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", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Declaration of serialVersionUID Field on Serializable Class.
	 * <p>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>.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingSerialVersion"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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. Class.getMethod(String name, Class ... args )
   invoked with arguments ("foo", null)).

Option id:
"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Varargs Argument Needing a Cast in Method/Constructor Invocation.
	 * <p>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>).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.autoboxing"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Boxing/Unboxing Conversion.
	 * <p>When enabled, the compiler will issue an error or a warning whenever a boxing or an unboxing
	 *    conversion is performed.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.autoboxing"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Use of Annotation Type as Super Interface.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"ignore"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing <code>@Override</code> Annotation.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Reporting Missing @Override Annotation for interface method implementation.
When enabled, the compiler will issue an error or a warning whenever encountering a method
   declaration which overrides or implements a superinterface method but has no @Override annotation.
This option only has an effect if the compiler compliance is 1.6 or greater.
The severity of the problem is controlled with option COMPILER_PB_MISSING_OVERRIDE_ANNOTATION.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation"
Possible values:
{ "enabled", "disabled" }
Default:
"enabled"

Since:
3.6
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing <code>@Override</code> Annotation for interface method implementation.
	 * <p>When enabled, the compiler will issue an error or a warning whenever encountering a method
	 *    declaration which overrides or implements a superinterface method but has no <code>@Override</code> annotation.</p>
	 * <p>This option only has an effect if the compiler compliance is 1.6 or greater.</p>
	 * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_MISSING_OVERRIDE_ANNOTATION}.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
	 * </dl>
	 * @since 3.6
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_MISSING_OVERRIDE_ANNOTATION_FOR_INTERFACE_METHOD_IMPLEMENTATION = PLUGIN_ID + ".compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation"; //$NON-NLS-1$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"ignore"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing <code>@Deprecated</code> Annotation.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Reporting Missing HashCode Method.
When enabled, the compiler will issue an error or a warning if a type
overrides Object.equals(Object) but does not override hashCode().

Option id:
"org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.5
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing HashCode Method.
	 * <p>When enabled, the compiler will issue an error or a warning if a type
	 * overrides Object.equals(Object) but does not override hashCode().</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.5
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_MISSING_HASHCODE_METHOD = PLUGIN_ID + ".compiler.problem.missingHashCodeMethod"; //$NON-NLS-1$
	
Compiler option ID: Reporting Dead Code.
When enabled, the compiler will issue an error or a warning if some non fatal dead code is detected. For instance, if (false) foo();
is not reported as truly unreachable code by the Java Language Specification. If this diagnostic is enabled, then the invocation of foo() is
going to be signaled as being dead code.

Option id:
"org.eclipse.jdt.core.compiler.problem.deadCode"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.5
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Dead Code.
	 * <p>When enabled, the compiler will issue an error or a warning if some non fatal dead code is detected. For instance, <code>if (false) foo();</code>
	 * is not reported as truly unreachable code by the Java Language Specification. If this diagnostic is enabled, then the invocation of <code>foo()</code> is
	 * going to be signaled as being dead code.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deadCode"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.5
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_DEAD_CODE = PLUGIN_ID + ".compiler.problem.deadCode"; //$NON-NLS-1$
	
Compiler option ID: Reporting Dead Code Inside Trivial If Statement.
When enabled, the compiler will signal presence of dead code inside trivial IF statement, e.g. if (DEBUG)....
The severity of the problem is controlled with option COMPILER_PB_DEAD_CODE.

Option id:
"org.eclipse.jdt.core.compiler.problem.deadCodeInTrivialIfStatement"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.5
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Dead Code Inside Trivial If Statement.
	 * <p>When enabled, the compiler will signal presence of dead code inside trivial IF statement, e.g. <code>if (DEBUG)...</code>.</p>
	 * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_DEAD_CODE}.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deadCodeInTrivialIfStatement"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.5
	 * @category CompilerOptionID
	 */	
	public static final String COMPILER_PB_DEAD_CODE_IN_TRIVIAL_IF_STATEMENT = PLUGIN_ID + ".compiler.problem.deadCodeInTrivialIfStatement"; //$NON-NLS-1$
	
Compiler option ID: Reporting Incomplete Enum Switch.
When enabled, the compiler will issue an error or a warning regarding each enum constant for which a corresponding case label is lacking. Reporting is further controlled by the option COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT.

Option id:
"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Incomplete Enum Switch.
	 * <p>When enabled, the compiler will issue an error or a warning
	 * 		regarding each enum constant for which a corresponding case label is lacking.
	 * 		Reporting is further controlled by the option {@link #COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT}.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</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$
	
Compiler option ID: Reporting Missing Enum Case In Switch Despite An Existing Default Case.
This option further controls the option COMPILER_PB_INCOMPLETE_ENUM_SWITCH:
	

	
If enabled the compiler will report problems about missing enum constants even if a default case exists
		in the same switch statement.
 
If disabled existence of a default case is considered as sufficient to make a switch statement complete.
 
 This option has no effect if COMPILER_PB_INCOMPLETE_ENUM_SWITCH is set to "ignore".

Option id:
"org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Enum Case In Switch Despite An Existing Default Case.
	 * <p>This option further controls the option {@link #COMPILER_PB_INCOMPLETE_ENUM_SWITCH}:</p>
	 * 	<ul>
	 * 	<li>If enabled the compiler will report problems about missing enum constants even if a default case exists
	 * 		in the same switch statement.</li>
	 *  <li>If disabled existence of a default case is considered as sufficient to make a switch statement complete.</li>
	 *  </ul>
	 *  This option has no effect if {@link #COMPILER_PB_INCOMPLETE_ENUM_SWITCH} is set to <code>"ignore"</code>.
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT = PLUGIN_ID + ".compiler.problem.missingEnumCaseDespiteDefault"; //$NON-NLS-1$
	
Compiler option ID: Reporting Missing Default Case In Switch.
When enabled, the compiler will issue an error or a warning 
		against each switch statement that lacks a default case.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingDefaultCase"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Default Case In Switch.
	 * <p>When enabled, the compiler will issue an error or a warning 
	 * 		against each switch statement that lacks a default case.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingDefaultCase"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_SWITCH_MISSING_DEFAULT_CASE = PLUGIN_ID + ".compiler.problem.missingDefaultCase"; //$NON-NLS-1$
	
Since:
3.1
Deprecated:
Use COMPILER_PB_NULL_REFERENCE instead.
@category
DeprecatedOptionID/**
	 * @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$
	
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:
   LABEL: { break; }

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedLabel"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.2
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unreferenced Label.
	 * <p>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:</p>
	 *    <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", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.invalidJavadoc"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Invalid Javadoc Comment.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadoc"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: 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 COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY.

Option id:
"org.eclipse.jdt.core.compiler.problem.invalidJavadocTags"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Invalid Javadoc Tags.
	 * <p>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.</p>
	 * <p>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}.</p>
	 * <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$
	
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 COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY.

Option id:
"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Invalid Javadoc Tags with Deprecated References.
	 * <p>Specify whether the compiler will report deprecated references used in Javadoc tags.</p>
	 * <p>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}.</p>
	 * <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$
	
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 COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY.

Option id:
"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Invalid Javadoc Tags with Not Visible References.
	 * <p>Specify whether the compiler will report non-visible references used in Javadoc tags.</p>
	 * <p>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}.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility"
Possible values:
{ "public", "protected", "default", "private" }
Default:
"public"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Visibility Level For Invalid Javadoc Tags.
	 * <p>Set the minimum visibility level for Javadoc tag problems. Below this level problems will be ignored.</p>
	 * <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$
	
Compiler option ID: Reporting missing tag description.
When enabled, the compiler will report a warning or an error for any Javadoc tag missing a required description.
The severity of the problem is controlled with option COMPILER_PB_INVALID_JAVADOC.
It does not depend on option COMPILER_PB_INVALID_JAVADOC_TAGS.
When this option is valued to COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_STANDARD_TAGS, a subset of the standard Javadoc tags
      that have a description, text or label are checked. While this set may grow in the future, note that user-defined tags are not and will not be checked.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription"
Possible values:
{ "return_tag", "all_standard_tags", "no_tag" }
Default:
"return_tag"

Since:
3.4
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting missing tag description.
	 * <p>When enabled, the compiler will report a warning or an error for any Javadoc tag missing a required description.</p>
	 * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_INVALID_JAVADOC}.</p>
	 * <p>It does not depend on option {@link #COMPILER_PB_INVALID_JAVADOC_TAGS}.</p>
	 * <p>When this option is valued to {@link #COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_STANDARD_TAGS},
	 *       a subset of the standard <a href="http://download.oracle.com/javase/6/docs/technotes/tools/windows/javadoc.html#javadoctags">Javadoc tags</a>
	 *       that have a description, text or label are checked. While this set may grow in the future, note that user-defined tags are not and will not be checked.</p>
	 * <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_standard_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$
	
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 COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingJavadocTags"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Javadoc Tags.
	 * <p>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.</p>
	 * <p>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}.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTags"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility"
Possible values:
{ "public", "protected", "default", "private" }
Default:
"public"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Visibility Level For Missing Javadoc Tags.
	 * <p>Set the minimum visibility level for Javadoc missing tag problems. Below this level problems will be ignored.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Javadoc Tags on Overriding Methods.
	 * <p>Specify whether the compiler will verify overriding methods in order to report Javadoc missing tag problems.</p>
	 * <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$
	
Compiler option ID: Reporting Missing Javadoc Tags for Method Type Parameters.
Specify whether a missing @param for a type parameter in a method declaration should be reported.
   When enabled, the compiler will issue a missing Javadoc tag error or warning for a type parameter without a 
   corresponding @param tag.
This option only has an effect if the compiler compliance is 1.5 or greater.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.7
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Javadoc Tags for Method Type Parameters.
	 * <p>Specify whether a missing <code>@param</code> for a type parameter in a method declaration should be reported.
	 *    When enabled, the compiler will issue a missing Javadoc tag error or warning for a type parameter without a 
	 *    corresponding <code>@param</code> tag.</p>
	 * <p>This option only has an effect if the compiler compliance is 1.5 or greater.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_METHOD_TYPE_PARAMETERS = PLUGIN_ID + ".compiler.problem.missingJavadocTagsMethodTypeParameters"; //$NON-NLS-1$
	
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 COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingJavadocComments"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Javadoc Comments.
	 * <p>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.</p>
	 * <p>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}.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocComments"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility"
Possible values:
{ "public", "protected", "default", "private" }
Default:
"public"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Visibility Level For Missing Javadoc Comments.
	 * <p>Set the minimum visibility level for missing Javadoc problems. Below this level problems will be ignored.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Javadoc Comments on Overriding Methods.
	 * <p>Specify whether the compiler will verify overriding methods in order to report missing Javadoc comment problems.</p>
	 * <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$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"warning"

Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Usage of <code>char[]</code> Expressions in String Concatenations.
	 * <p>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>).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Maximum Number of Problems Reported per Compilation Unit.
Specify the maximum number of problems reported on each compilation unit.

Option id:
"org.eclipse.jdt.core.compiler.maxProblemPerUnit"
Possible values:
"<n>" where <n> is zero or a positive integer (if zero then all problems are reported).
Default:
"100"

Since:
2.0
@category
CompilerOptionID/**
	 * Compiler option ID: Maximum Number of Problems Reported per Compilation Unit.
	 * <p>Specify the maximum number of problems reported on each compilation unit.</p>
	 * <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$
	
Compiler option ID: 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, optional errors are not fatal. Non-optional errors are
   always fatal.

Option id:
"org.eclipse.jdt.core.compiler.problem.fatalOptionalError"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.2
@category
CompilerOptionID/**
	 * Compiler option ID: Treating Optional Error as Fatal.
	 * <p>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.</p>
	 * <p>When disabled, optional errors are only considered as warnings, still carrying an error indication to make them more
	 *    severe. Note that by default, optional errors are not fatal. Non-optional errors are
	 *    always fatal.</p>
	 * <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>"disabled"</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$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"ignore"

Since:
3.2
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Parameter Assignment.
	 * <p>When enabled, the compiler will issue an error or a warning if a parameter is
	 *    assigned to.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.parameterAssignment"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Reporting a method that qualifies as static, but not declared static.
When enabled, the compiler will issue an error or a warning if a method has
   not been declared as static, even though it qualifies as one.

Option id:
"org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.7
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting a method that qualifies as static, but not declared static.
	 * <p>When enabled, the compiler will issue an error or a warning if a method has
	 *    not been declared as <code>static</code>, even though it qualifies as one.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$
	
Compiler option ID: Reporting a method that may qualify as static, but not declared static.
When enabled, the compiler will issue an error or a warning if a method has
   not been declared as static, even though it may qualify as one,
   when another method doesn't override it.

Option id:
"org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.7
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting a method that may qualify as static, but not declared static.
	 * <p>When enabled, the compiler will issue an error or a warning if a method has
	 *    not been declared as <code>static</code>, even though it may qualify as one,
	 *    when another method doesn't override it.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$
	
Compiler option ID: Reporting a resource that is not closed properly.
When enabled, the compiler will issue an error or a warning if
   a local variable holds a value of type java.lang.AutoCloseable (compliance>=1.7) 
   or a value of type java.io.Closeable (compliance<=1.6) and if
   flow analysis shows that the method close() is not invoked locally on that value.

Option id:
"org.eclipse.jdt.core.compiler.problem.unclosedCloseable"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting a resource that is not closed properly.
	 * <p>When enabled, the compiler will issue an error or a warning if
	 *    a local variable holds a value of type <code>java.lang.AutoCloseable</code> (compliance>=1.7) 
	 *    or a value of type <code>java.io.Closeable</code> (compliance<=1.6) and if
	 *    flow analysis shows that the method <code>close()</code> is not invoked locally on that value.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unclosedCloseable"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.unclosedCloseable"; //$NON-NLS-1$
	
Compiler option ID: Reporting a resource that may not be closed properly.
When enabled, the compiler will issue an error or a warning if
   a local variable holds a value of type java.lang.AutoCloseable (compliance>=1.7) 
   or a value of type java.io.Closeable (compliance<=1.6) and if
   flow analysis shows that the method close() is 
   not invoked locally on that value for all execution paths.

Option id:
"org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting a resource that may not be closed properly.
	 * <p>When enabled, the compiler will issue an error or a warning if
	 *    a local variable holds a value of type <code>java.lang.AutoCloseable</code> (compliance>=1.7) 
	 *    or a value of type <code>java.io.Closeable</code> (compliance<=1.6) and if
	 *    flow analysis shows that the method <code>close()</code> is 
	 *    not invoked locally on that value for all execution paths.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$
	
Compiler option ID: Reporting a resource that is not managed by try-with-resources.
When enabled, the compiler will issue an error or a warning if a local variable 
	  holds a value of type java.lang.AutoCloseable, and if the method
   close() is explicitly invoked on that resource, but the resource is
   not managed by a try-with-resources block.

Option id:
"org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting a resource that is not managed by try-with-resources.
	 * <p>When enabled, the compiler will issue an error or a warning if a local variable 
	 * 	  holds a value of type <code>java.lang.AutoCloseable</code>, and if the method
	 *    <code>close()</code> is explicitly invoked on that resource, but the resource is
	 *    not managed by a try-with-resources block.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE = PLUGIN_ID + ".compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$

	
Compiler option ID: Reporting a method invocation providing an argument of an unlikely type.
When enabled, the compiler will issue an error or warning when certain well-known Collection methods that take an 'Object', like e.g. Map.get(Object), are used with an argument type that seems to be not related to the corresponding type argument of the Collection.
By default, this analysis will apply some heuristics to determine whether or not two types may or may not be related, which can be changed via option COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE_STRICT.

Option id:
"org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentType"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.13
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting a method invocation providing an argument of an unlikely type.
	 * <p>When enabled, the compiler will issue an error or warning when certain well-known Collection methods
	 *    that take an 'Object', like e.g. {@link Map#get(Object)}, are used with an argument type
	 *    that seems to be not related to the corresponding type argument of the Collection.</p>
	 * <p>By default, this analysis will apply some heuristics to determine whether or not two
	 *    types may or may not be related, which can be changed via option
	 *    {@link #COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE_STRICT}.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentType"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.13
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE = PLUGIN_ID + ".compiler.problem.unlikelyCollectionMethodArgumentType"; //$NON-NLS-1$

	
Compiler option ID: Perform strict analysis against the expected type of collection methods.
This is a sub-option of COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE, which will replace the heuristics with strict compatibility checks, i.e., each argument that is not strictly compatible with the expected type will trigger an error or warning.
This option has no effect if COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE is set to "ignore".

Option id:
"org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentTypeStrict"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.13
@category
CompilerOptionID/**
	 * Compiler option ID: Perform strict analysis against the expected type of collection methods.
	 * <p>This is a sub-option of {@link #COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE},
	 *    which will replace the heuristics with strict compatibility checks,
	 *    i.e., each argument that is not strictly compatible with the expected type will trigger an error or warning.</p>
	 * <p>This option has no effect if {@link #COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE} is set to <code>"ignore"</code>.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentTypeStrict"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.13
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNLIKELY_COLLECTION_METHOD_ARGUMENT_TYPE_STRICT = PLUGIN_ID + ".compiler.problem.unlikelyCollectionMethodArgumentTypeStrict"; //$NON-NLS-1$

	
Compiler option ID: Reporting a method invocation providing an argument of an unlikely type to method 'equals'.
 When enabled, the compiler will issue an error or warning when Object.equals(Object) is used with an argument type that seems to be not related to the receiver's type, or correspondingly when the arguments of Objects.equals(Object, Object) have types that seem to be not related to each other. 

Option id:
"org.eclipse.jdt.core.compiler.problem.unlikelyEqualsArgumentType"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"info"

Since:
3.13
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting a method invocation providing an argument of an unlikely type to method 'equals'.
	 * <p>
	 * When enabled, the compiler will issue an error or warning when {@link java.lang.Object#equals(Object)} is used with an argument type 
	 * that seems to be not related to the receiver's type, or correspondingly when the arguments of {@link java.util.Objects#equals(Object, Object)}
	 * have types that seem to be not related to each other.
	 * </p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unlikelyEqualsArgumentType"</code></dd>
	 * <dt>Possible values:</dt>
	 * <dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"info"</code></dd>
	 * </dl>
	 * 
	 * @since 3.13
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNLIKELY_EQUALS_ARGUMENT_TYPE = PLUGIN_ID + ".compiler.problem.unlikelyEqualsArgumentType"; //$NON-NLS-1$

	
Compiler option ID: Reporting when public API uses a non-API type.

This option is relevant only when compiling code in a named module (at compliance 9 or greater).
 When enabled, the compiler will issue an error or warning when public API mentions a type that is not accessible to clients. Here, public API refers to signatures of public fields and methods declared by a public type in an exported package. In these positions types are complained against that are either not public or not in an exported package. Export qualification is not taken into account. If a type in one of these positions is declared in another module that is required by the current module, but without the transitive modifier, this is reported as a problem, too. 

Option id:
"org.eclipse.jdt.core.compiler.problem.APILeak"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.14
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting when public API uses a non-API type.
	 * <p>
	 * This option is relevant only when compiling code in a named module (at compliance 9 or greater).
	 * <p>
	 * When enabled, the compiler will issue an error or warning when public API mentions a type that is not
	 * accessible to clients. Here, public API refers to signatures of public fields and methods declared
	 * by a public type in an exported package.
	 * In these positions types are complained against that are either not public or not in an exported package.
	 * Export qualification is not taken into account.
	 * If a type in one of these positions is declared in another module that is required by the current module,
	 * but without the {@code transitive} modifier, this is reported as a problem, too.
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.APILeak"</code></dd>
	 * <dt>Possible values:</dt>
	 * <dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * 
	 * @since 3.14
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_API_LEAKS = PLUGIN_ID + ".compiler.problem.APILeak"; //$NON-NLS-1$
	
	
Compiler option ID: Reporting when a module requires an auto module with an unstable name.

The name of an auto module name is considered unstable when it is derived from a file name rather than
being declared in the module's MANIFEST.MF.

When enabled, the compiler will issue an error or warning when a module references an auto module
with an unstable name in its 'requires' clause.

Option id:
"org.eclipse.jdt.core.compiler.problem.unstableAutoModuleName"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.14
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting when a module requires an auto module with an unstable name.
	 * <p>
	 * The name of an auto module name is considered unstable when it is derived from a file name rather than
	 * being declared in the module's MANIFEST.MF.
	 * <p>
	 * When enabled, the compiler will issue an error or warning when a module references an auto module
	 * with an unstable name in its 'requires' clause.
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unstableAutoModuleName"</code></dd>
	 * <dt>Possible values:</dt>
	 * <dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * 
	 * @since 3.14
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNSTABLE_AUTO_MODULE_NAME = PLUGIN_ID + ".compiler.problem.unstableAutoModuleName"; //$NON-NLS-1$

	
Compiler option ID: Reporting when a @SuppressWarnings annotation might be unused, but exact information is not available. 
 This issue occurs when a suppress warnings token (like, e.g., "unused") represents a group of problems, and some of the problems in that group are currently disabled (configured as "ignore"). In this situation the compiler may not know if none of the problems in that group could be found within the annotated code section. 
 When enabled, the compiler will issue an error, warning or info when a @SuppressWarnings annotation was not observed to be necessary, but analysis of the suppressed group of problems was incomplete. 

Option id:
"org.eclipse.jdt.core.compiler.problem.suppressWarningsNotFullyAnalysed"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"info"

Since:
3.20
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting when a {@code @SuppressWarnings} annotation might be unused, but exact information is not available.
	 * <p>
	 * This issue occurs when a suppress warnings token (like, e.g., {@code "unused"}) represents a group of problems,
	 * and some of the problems in that group are currently disabled (configured as "ignore").
	 * In this situation the compiler may not know if none of the problems in that group could be found within the
	 * annotated code section.
	 * <p>
	 * When enabled, the compiler will issue an error, warning or info when a {@code @SuppressWarnings} annotation
	 * was not observed to be necessary, but analysis of the suppressed group of problems was incomplete.
	 *  
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.suppressWarningsNotFullyAnalysed"</code></dd>
	 * <dt>Possible values:</dt>
	 * <dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"info"</code></dd>
	 * </dl>
	 * 
	 * @since 3.20
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_SUPPRESS_WARNINGS_NOT_FULLY_ANALYSED = PLUGIN_ID + ".compiler.problem.suppressWarningsNotFullyAnalysed"; //$NON-NLS-1$
	
	
Compiler option ID: Annotation-based Null Analysis.
This option controls whether the compiler will use null annotations for
   improved analysis of (potential) null references.
When enabled, the compiler will interpret the annotation types defined using COMPILER_NONNULL_ANNOTATION_NAME and COMPILER_NULLABLE_ANNOTATION_NAME as specifying whether or not a given type includes the value null.
The effect of these analyses is further controlled by the options COMPILER_PB_NULL_SPECIFICATION_VIOLATION, COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT and COMPILER_PB_NULL_UNCHECKED_CONVERSION. 

Option id:
"org.eclipse.jdt.core.compiler.annotation.nullanalysis"
Possible values:
{ "disabled", "enabled" }
Default:
"disabled"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Annotation-based Null Analysis.
	 * <p>This option controls whether the compiler will use null annotations for
	 *    improved analysis of (potential) null references.</p>
	 * <p>When enabled, the compiler will interpret the annotation types defined using
	 *    {@link #COMPILER_NONNULL_ANNOTATION_NAME} and {@link #COMPILER_NULLABLE_ANNOTATION_NAME}
	 *    as specifying whether or not a given type includes the value <code>null</code>.</p>
	 * <p>The effect of these analyses is further controlled by the options
	 *    {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION},
	 *    {@link #COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT} and
	 *    {@link #COMPILER_PB_NULL_UNCHECKED_CONVERSION}.
	 * </p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nullanalysis"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "disabled", "enabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_ANNOTATION_NULL_ANALYSIS = PLUGIN_ID + ".compiler.annotation.nullanalysis"; //$NON-NLS-1$
	
Compiler option ID: Name of Annotation Type for Nullable Types.
This option defines a fully qualified Java type name that the compiler may use
   to perform special null analysis.
If the annotation specified by this option is applied to a type in a method
   signature or variable declaration, this will be interpreted as a specification
   that null is a legal value in that position. Currently supported
   positions are: method parameters, method return type, fields and local variables.
If a value whose type is annotated with this annotation is dereferenced without checking for null, the compiler will trigger a diagnostic as further controlled by COMPILER_PB_POTENTIAL_NULL_REFERENCE.
The compiler may furthermore check adherence to the null specification as further controlled by COMPILER_PB_NULL_SPECIFICATION_VIOLATION, COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT and COMPILER_PB_NULL_UNCHECKED_CONVERSION.
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.annotation.nullable"
Possible values:
any legal, fully qualified Java type name; must resolve to an annotation type.
Default:
"org.eclipse.jdt.annotation.Nullable"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Name of Annotation Type for Nullable Types.
	 * <p>This option defines a fully qualified Java type name that the compiler may use
	 *    to perform special null analysis.</p>
	 * <p>If the annotation specified by this option is applied to a type in a method
	 *    signature or variable declaration, this will be interpreted as a specification
	 *    that <code>null</code> is a legal value in that position. Currently supported
	 *    positions are: method parameters, method return type, fields and local variables.</p>
	 * <p>If a value whose type
	 *    is annotated with this annotation is dereferenced without checking for null,
	 *    the compiler will trigger a diagnostic as further controlled by
	 *    {@link #COMPILER_PB_POTENTIAL_NULL_REFERENCE}.</p>
	 * <p>The compiler may furthermore check adherence to the null specification as
	 *    further controlled by {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION},
	 *    {@link #COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT} and
	 *    {@link #COMPILER_PB_NULL_UNCHECKED_CONVERSION}.</p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nullable"</code></dd>
	 * <dt>Possible values:</dt><dd>any legal, fully qualified Java type name; must resolve to an annotation type.</dd>
	 * <dt>Default:</dt><dd><code>"org.eclipse.jdt.annotation.Nullable"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_NULLABLE_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nullable"; //$NON-NLS-1$
	
Compiler option ID: Names of Secondary Annotation Types for Nullable Types.
This option defines a comma-separated list of fully qualified Java type names
   that the compiler may use to perform special null analysis.
The annotation types identified by the names in this list are interpreted in the same way as the annotation identified by COMPILER_NULLABLE_ANNOTATION_NAME. The intention is to support libraries using different sets of null annotations, in addition to those used by the current project. Secondary null annotations should not be used in the project's own source code.
JDT will never actively use any secondary annotation names from this list, i.e., inferred null annotations and content assist proposals mentioning null annotations are always rendered using the primary name from COMPILER_NULLABLE_ANNOTATION_NAME.
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.annotation.nullable.secondary"
Possible values:
a comma-separated list of legal, fully qualified Java type names;
    each name in the list must resolve to an annotation type.
Default:
""

Since:
3.12
@category
CompilerOptionID/**
	 * Compiler option ID: Names of Secondary Annotation Types for Nullable Types.
	 * <p>This option defines a comma-separated list of fully qualified Java type names
	 *    that the compiler may use to perform special null analysis.</p>
	 * <p>The annotation types identified by the names in this list are interpreted in the same way
	 *    as the annotation identified by {@link #COMPILER_NULLABLE_ANNOTATION_NAME}.
	 *    The intention is to support libraries using different sets of null annotations,
	 *    in addition to those used by the current project. Secondary null annotations should not be
	 *    used in the project's own source code.</p>
	 * <p>JDT will never actively use any secondary annotation names from this list,
	 *    i.e., inferred null annotations and content assist proposals mentioning null annotations
	 *    are always rendered using the primary name from {@link #COMPILER_NULLABLE_ANNOTATION_NAME}.</p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nullable.secondary"</code></dd>
	 * <dt>Possible values:</dt><dd>a comma-separated list of legal, fully qualified Java type names;
	 *     each name in the list must resolve to an annotation type.</dd>
	 * <dt>Default:</dt><dd><code>""</code></dd>
	 * </dl>
	 * @since 3.12
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_NULLABLE_ANNOTATION_SECONDARY_NAMES = PLUGIN_ID + ".compiler.annotation.nullable.secondary"; //$NON-NLS-1$
	
Compiler option ID: Name of Annotation Type for Non-Null Types.
This option defines a fully qualified Java type name that the compiler may use
   to perform special null analysis.
If the annotation specified by this option is applied to a type in a method
   signature or variable declaration, this will be interpreted as a specification
   that null is not a legal value in that position. Currently
   supported positions are: method parameters, method return type, fields and local variables.
For values declared with this annotation, the compiler will never trigger a null reference diagnostic (as controlled by COMPILER_PB_POTENTIAL_NULL_REFERENCE and COMPILER_PB_NULL_REFERENCE), because the assumption is made that null will never occur at runtime in these positions.
The compiler may furthermore check adherence to the null specification as further controlled by COMPILER_PB_NULL_SPECIFICATION_VIOLATION, COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT and COMPILER_PB_NULL_UNCHECKED_CONVERSION.
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.annotation.nonnull"
Possible values:
any legal, fully qualified Java type name; must resolve to an annotation type.
Default:
"org.eclipse.jdt.annotation.NonNull"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Name of Annotation Type for Non-Null Types.
	 * <p>This option defines a fully qualified Java type name that the compiler may use
	 *    to perform special null analysis.</p>
	 * <p>If the annotation specified by this option is applied to a type in a method
	 *    signature or variable declaration, this will be interpreted as a specification
	 *    that <code>null</code> is <b>not</b> a legal value in that position. Currently
	 *    supported positions are: method parameters, method return type, fields and local variables.</p>
	 * <p>For values declared with this annotation, the compiler will never trigger a null
	 *    reference diagnostic (as controlled by {@link #COMPILER_PB_POTENTIAL_NULL_REFERENCE}
	 *    and {@link #COMPILER_PB_NULL_REFERENCE}), because the assumption is made that null
	 *    will never occur at runtime in these positions.</p>
	 * <p>The compiler may furthermore check adherence to the null specification as further
	 *    controlled by {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION},
	 *    {@link #COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT} and
	 *    {@link #COMPILER_PB_NULL_UNCHECKED_CONVERSION}.</p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nonnull"</code></dd>
	 * <dt>Possible values:</dt><dd>any legal, fully qualified Java type name; must resolve to an annotation type.</dd>
	 * <dt>Default:</dt><dd><code>"org.eclipse.jdt.annotation.NonNull"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_NONNULL_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nonnull"; //$NON-NLS-1$
	
Compiler option ID: Names of Secondary Annotation Types for Non-Null Types.
This option defines a comma-separated list of fully qualified Java type names
   that the compiler may use to perform special null analysis.
The annotation types identified by the names in this list are interpreted in the same way as the annotation identified by COMPILER_NONNULL_ANNOTATION_NAME. The intention is to support libraries using different sets of null annotations, in addition to those used by the current project. Secondary null annotations should not be used in the project's own source code.
JDT will never actively use any secondary annotation names from this list, i.e., inferred null annotations and content assist proposals mentioning null annotations are always rendered using the primary name from COMPILER_NONNULL_ANNOTATION_NAME.
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.annotation.nonnull.secondary"
Possible values:
a comma-separated list of legal, fully qualified Java type names;
    each name in the list must resolve to an annotation type.
Default:
""

Since:
3.12
@category
CompilerOptionID/**
	 * Compiler option ID: Names of Secondary Annotation Types for Non-Null Types.
	 * <p>This option defines a comma-separated list of fully qualified Java type names
	 *    that the compiler may use to perform special null analysis.</p>
	 * <p>The annotation types identified by the names in this list are interpreted in the same way
	 *    as the annotation identified by {@link #COMPILER_NONNULL_ANNOTATION_NAME}.
	 *    The intention is to support libraries using different sets of null annotations,
	 *    in addition to those used by the current project. Secondary null annotations should not be
	 *    used in the project's own source code.</p>
	 * <p>JDT will never actively use any secondary annotation names from this list,
	 *    i.e., inferred null annotations and content assist proposals mentioning null annotations
	 *    are always rendered using the primary name from {@link #COMPILER_NONNULL_ANNOTATION_NAME}.</p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nonnull.secondary"</code></dd>
	 * <dt>Possible values:</dt><dd>a comma-separated list of legal, fully qualified Java type names;
	 *     each name in the list must resolve to an annotation type.</dd>
	 * <dt>Default:</dt><dd><code>""</code></dd>
	 * </dl>
	 * @since 3.12
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_NONNULL_ANNOTATION_SECONDARY_NAMES = PLUGIN_ID + ".compiler.annotation.nonnull.secondary"; //$NON-NLS-1$
	
Compiler option ID: Name of Annotation Type to specify a nullness default for unannotated types.
This option defines a fully qualified Java type name that the compiler may use
   to perform special null analysis.
If the annotation is applied without an argument, all unannotated types in method signatures and field declarations within the annotated element will be treated as if they were specified with the non-null annotation (see COMPILER_NONNULL_ANNOTATION_NAME).
If the annotation is applied with the constant false as its argument
   all corresponding defaults at outer scopes will be canceled for the annotated element.
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.annotation.nonnullbydefault"
Possible values:
any legal, fully qualified Java type name; must resolve to an annotation type.
    That annotation type should have exactly one boolean parameter.
Default:
"org.eclipse.jdt.annotation.NonNullByDefault"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Name of Annotation Type to specify a nullness default for unannotated types.
	 * <p>This option defines a fully qualified Java type name that the compiler may use
	 *    to perform special null analysis.</p>
	 * <p>If the annotation is applied without an argument, all unannotated types in method signatures
	 *    and field declarations within the annotated element will be treated as if they were specified
	 *    with the non-null annotation (see {@link #COMPILER_NONNULL_ANNOTATION_NAME}).</p>
	 * <p>If the annotation is applied with the constant <code>false</code> as its argument
	 *    all corresponding defaults at outer scopes will be canceled for the annotated element.</p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nonnullbydefault"</code></dd>
	 * <dt>Possible values:</dt><dd>any legal, fully qualified Java type name; must resolve to an annotation type.
	 *     That annotation type should have exactly one boolean parameter.</dd>
	 * <dt>Default:</dt><dd><code>"org.eclipse.jdt.annotation.NonNullByDefault"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nonnullbydefault"; //$NON-NLS-1$
	
Compiler option ID: Names of Secondary Annotation Types to specify a nullness default for unannotated types.
This option defines a comma-separated list of fully qualified Java type names
   that the compiler may use to perform special null analysis.
The annotation types identified by the names in this list are interpreted in the same way as the annotation identified by COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME. The intention is to support libraries using different sets of null annotations, in addition to those used by the current project. Secondary null annotations should not be used in the project's own source code.
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary"
Possible values:
a comma-separated list of legal, fully qualified Java type names;
    each name in the list must resolve to an annotation type.
Default:
""

Since:
3.12
@category
CompilerOptionID/**
	 * Compiler option ID: Names of Secondary Annotation Types to specify a nullness default for unannotated types.
	 * <p>This option defines a comma-separated list of fully qualified Java type names
	 *    that the compiler may use to perform special null analysis.</p>
	 * <p>The annotation types identified by the names in this list are interpreted in the same way
	 *    as the annotation identified by {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}.
	 *    The intention is to support libraries using different sets of null annotations,
	 *    in addition to those used by the current project. Secondary null annotations should not be
	 *    used in the project's own source code.</p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary"</code></dd>
	 * <dt>Possible values:</dt><dd>a comma-separated list of legal, fully qualified Java type names;
	 *     each name in the list must resolve to an annotation type.</dd>
	 * <dt>Default:</dt><dd><code>""</code></dd>
	 * </dl>
	 * @since 3.12
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_SECONDARY_NAMES = PLUGIN_ID + ".compiler.annotation.nonnullbydefault.secondary"; //$NON-NLS-1$
	
Compiler option ID: Reporting missing default nullness annotation.
When enabled, the compiler will issue an error or a warning in the following cases:

 When a package does not contain a default nullness annotation, as a result of missing package-info.java 
or missing default nullness annotation in package-info.java.
 When a type inside a default package does not contain a default nullness annotation.

This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation"
Possible values:
{ "error", "warning", "info", "ignore" }.
Default:
"ignore"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting missing default nullness annotation.
	 * <p>When enabled, the compiler will issue an error or a warning in the following cases:</p>
	 * <ul>
	 * <li> When a package does not contain a default nullness annotation, as a result of missing package-info.java 
	 * or missing default nullness annotation in package-info.java.</li>
	 * <li> When a type inside a default package does not contain a default nullness annotation.</li>
	 * </ul>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code>.</dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION = PLUGIN_ID + ".compiler.annotation.missingNonNullByDefaultAnnotation"; //$NON-NLS-1$
	
Compiler option ID: Reporting Violations of Null Specifications.
Depending on this option, the compiler will issue either an error or a warning
   whenever one of the following situations is detected:
   

   
A method declared with a nonnull annotation returns a
       nullable expression.
   
A nullable expression is passed
       as an argument in a method call where the corresponding parameter of the called
       method is declared with a nonnull annotation.
   
A nullable expression is assigned
       to a local variable that is declared with a nonnull annotation.
   
A method that overrides an inherited method declared with a nonnull annotation
       tries to relax that contract by specifying a nullable annotation
       (prohibition of contravariant return).
   
A method that overrides an inherited method which has a nullable declaration
       for at least one of its parameters, tries to tighten that null contract by
       specifying a nonnull annotation for its corresponding parameter
       (prohibition of covariant parameters).
   
A non-static field with a nonnull annotation is not definitely assigned at
       the end of each constructor.
   
A static field with a nonnull annotation is not definitely assigned in static initializers.
   
   In the above an expression is considered as nullable if
   either it is statically known to evaluate to the value null, or if it is
   declared with a nullable annotation.
The compiler options COMPILER_NONNULL_ANNOTATION_NAME and COMPILER_NULLABLE_ANNOTATION_NAME control which annotations the compiler shall interpret as nonnull or nullable annotations, respectively. 
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.problem.nullSpecViolation"
Possible values:
{ "error", "warning" }
Default:
"error"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Violations of Null Specifications.
	 * <p>Depending on this option, the compiler will issue either an error or a warning
	 *    whenever one of the following situations is detected:</p>
	 *    <ol>
	 *    <li>A method declared with a nonnull annotation returns a
	 *        <em>nullable</em> expression.</li>
	 *    <li>A <em>nullable</em> expression is passed
     *        as an argument in a method call where the corresponding parameter of the called
     *        method is declared with a nonnull annotation.</li>
	 *    <li>A <em>nullable</em> expression is assigned
     *        to a local variable that is declared with a nonnull annotation.</li>
	 *    <li>A method that overrides an inherited method declared with a nonnull annotation
	 *        tries to relax that contract by specifying a nullable annotation
	 *        (prohibition of contravariant return).</li>
	 *    <li>A method that overrides an inherited method which has a nullable declaration
	 *        for at least one of its parameters, tries to tighten that null contract by
	 *        specifying a nonnull annotation for its corresponding parameter
	 *        (prohibition of covariant parameters).</li>
	 *    <li>A non-static field with a nonnull annotation is not definitely assigned at
	 *        the end of each constructor.</li>
	 *    <li>A static field with a nonnull annotation is not definitely assigned in static initializers.</li>
	 *    </ol>
	 *    In the above an expression is considered as <em>nullable</em> if
	 *    either it is statically known to evaluate to the value <code>null</code>, or if it is
	 *    declared with a nullable annotation.
	 * <p>The compiler options {@link #COMPILER_NONNULL_ANNOTATION_NAME} and
	 *    {@link #COMPILER_NULLABLE_ANNOTATION_NAME} control which annotations the compiler
	 *    shall interpret as nonnull or nullable annotations, respectively.
	 * </p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullSpecViolation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning" }</code></dd>
	 * <dt>Default:</dt><dd><code>"error"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_NULL_SPECIFICATION_VIOLATION = PLUGIN_ID + ".compiler.problem.nullSpecViolation"; //$NON-NLS-1$
	
Compiler option ID: Reporting conflicts between declared null annotation and inferred null value 
When enabled, the compiler will issue an error or a warning whenever one of the
   following situations is detected:
   

   
A method declared with a nonnull annotation returns an expression that is
         statically known to evaluate to a null value on some flow.
   
An expression that is statically known to evaluate to a null value on some flow
       is passed as an argument in a method call where the corresponding parameter of
       the called method is declared with a nonnull annotation.
   
An expression that is statically known to evaluate to a null value on some flow
       is assigned to a local variable that is declared with a nonnull annotation.
   
The compiler options COMPILER_NONNULL_ANNOTATION_NAME and COMPILER_NULLABLE_ANNOTATION_NAME control which annotations the compiler shall interpret as nonnull or nullable annotations, respectively. 
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"error"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting conflicts between declared null annotation and inferred null value 
	 * <p>When enabled, the compiler will issue an error or a warning whenever one of the
	 *    following situations is detected:</p>
	 *    <ol>
	 *    <li>A method declared with a nonnull annotation returns an expression that is
	 *          statically known to evaluate to a null value on some flow.</li>
	 *    <li>An expression that is statically known to evaluate to a null value on some flow
	 *        is passed as an argument in a method call where the corresponding parameter of
	 *        the called method is declared with a nonnull annotation.</li>
	 *    <li>An expression that is statically known to evaluate to a null value on some flow
	 *        is assigned to a local variable that is declared with a nonnull annotation.</li>
	 *    </ol>
	 * <p>The compiler options {@link #COMPILER_NONNULL_ANNOTATION_NAME} and
	 *    {@link #COMPILER_NULLABLE_ANNOTATION_NAME} control which annotations the compiler
	 *    shall interpret as nonnull or nullable annotations, respectively.
	 * </p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"error"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT = PLUGIN_ID + ".compiler.problem.nullAnnotationInferenceConflict"; //$NON-NLS-1$
	
Compiler option ID: Reporting unchecked conversion from a type with unknown nullness to a null annotated type
When enabled, the compiler will issue an error or a warning whenever one of the
   following situations is detected:
   

   
A method declared with a nonnull annotation returns an expression for which
       insufficient nullness information is available for statically proving that no
       flow will pass a null value at runtime.
   
An expression for which insufficient nullness information is available for
       statically proving that it will never evaluate to a null value at runtime
       is passed as an argument in a method call where the corresponding parameter of
       the called method is declared with a nonnull annotation.
   
An expression for which insufficient nullness information is available for
       statically proving that it will never evaluate to a null value at runtime
       is assigned to a local variable that is declared with a nonnull annotation.
   
Unchecked null conversion is usually a consequence of using other unannotated
   variables or methods.
The compiler options COMPILER_NONNULL_ANNOTATION_NAME and COMPILER_NULLABLE_ANNOTATION_NAME control which annotations the compiler shall interpret as nonnull or nullable annotations, respectively. 
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting unchecked conversion from a type with unknown nullness to a null annotated type
	 * <p>When enabled, the compiler will issue an error or a warning whenever one of the
	 *    following situations is detected:</p>
	 *    <ol>
	 *    <li>A method declared with a nonnull annotation returns an expression for which
	 *        insufficient nullness information is available for statically proving that no
	 *        flow will pass a null value at runtime.</li>
	 *    <li>An expression for which insufficient nullness information is available for
	 *        statically proving that it will never evaluate to a null value at runtime
	 *        is passed as an argument in a method call where the corresponding parameter of
	 *        the called method is declared with a nonnull annotation.</li>
	 *    <li>An expression for which insufficient nullness information is available for
	 *        statically proving that it will never evaluate to a null value at runtime
	 *        is assigned to a local variable that is declared with a nonnull annotation.</li>
	 *    </ol>
	 * <p>Unchecked null conversion is usually a consequence of using other unannotated
	 *    variables or methods.</p>
	 * <p>The compiler options {@link #COMPILER_NONNULL_ANNOTATION_NAME} and
	 *    {@link #COMPILER_NULLABLE_ANNOTATION_NAME} control which annotations the compiler
	 *    shall interpret as nonnull or nullable annotations, respectively.
	 * </p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_NULL_UNCHECKED_CONVERSION = PLUGIN_ID + ".compiler.problem.nullUncheckedConversion"; //$NON-NLS-1$
	
Compiler option ID: Reporting problems detected by pessimistic null analysis for free type variables.
Unless set to "ignore", type variables not affected by any explicit null annotation are pessimistically analyzed
in two directions: When reading a value of this type, it is assumed to be nullable. When this type appears as the required type
(i.e., at the left hand side of an assignment or variable initialization, or as the method return type against which a return statement
is being checked) the type is considered to require the nonnull property.
Problems reported due to this pessimistic analysis are reported with the level given in this option.
Since:
3.12
@category
CompilerOptionID

Option id:
"org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"
/**
	 * Compiler option ID: Reporting problems detected by pessimistic null analysis for free type variables.
	 * <p>Unless set to <code>"ignore"</code>, type variables not affected by any explicit null annotation are pessimistically analyzed
	 * in two directions: When reading a value of this type, it is assumed to be nullable. When this type appears as the required type
	 * (i.e., at the left hand side of an assignment or variable initialization, or as the method return type against which a return statement
	 * is being checked) the type is considered to require the nonnull property.</p>
	 * <p>Problems reported due to this pessimistic analysis are reported with the level given in this option.</p>
	 * @since 3.12
	 * @category CompilerOptionID
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 */
	public static final String COMPILER_PB_PESSIMISTIC_NULL_ANALYSIS_FOR_FREE_TYPE_VARIABLES = PLUGIN_ID + ".compiler.problem.pessimisticNullAnalysisForFreeTypeVariables"; //$NON-NLS-1$
	
Compiler option ID: Reporting Redundant Null Annotations.
When enabled, the compiler will issue an error or a warning when a non-null annotation (see COMPILER_NONNULL_ANNOTATION_NAME) is applied although the same effect is already achieved by a default applicable at the current location. Such a default may be set by using the annotation specified by the option COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME. 
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.8
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Redundant Null Annotations.
	 * <p>When enabled, the compiler will issue an error or a warning when a non-null annotation
	 *    (see {@link #COMPILER_NONNULL_ANNOTATION_NAME})
	 *    is applied although the same effect is already achieved by a default applicable at the
	 *    current location. Such a default may be set by using the annotation specified by the option
	 *    {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}.
	 * </p>
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.8
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_REDUNDANT_NULL_ANNOTATION = PLUGIN_ID + ".compiler.problem.redundantNullAnnotation"; //$NON-NLS-1$
	
Compiler option ID: Perform syntactic null analysis for fields.
When enabled, the compiler will detect certain syntactic constellations where a null
  related warning against a field reference would normally be raised but can be suppressed
   at low risk given that the same field reference was known to be non-null immediately before.

Option id:
"org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields"
Possible values:
{ "disabled", "enabled" }
Default:
"disabled"

Since:
3.9
@category
CompilerOptionID/**
	 * Compiler option ID: Perform syntactic null analysis for fields.
	 * <p>When enabled, the compiler will detect certain syntactic constellations where a null
	 *	  related warning against a field reference would normally be raised but can be suppressed
	 *    at low risk given that the same field reference was known to be non-null immediately before.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "disabled", "enabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.9
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS = JavaCore.PLUGIN_ID+".compiler.problem.syntacticNullAnalysisForFields"; //$NON-NLS-1$
	
Compiler option ID: Inheritance of null annotations.
When enabled, the compiler will check for each method without any explicit null annotations:
   If it overrides a method which has null annotations, it will treat the
   current method as if it had the same annotations as the overridden method.
Annotation inheritance will use the effective nullness of the overridden method after transitively applying inheritance and after applying any default nullness (see COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME) at the site of the overridden method.
If different implicit null annotations (from a nonnull default and/or overridden methods) are applicable
   to the same type in a method signature, this is flagged as an error 
   and an explicit null annotation must be used to disambiguate.

Option id:
"org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations"
Possible values:
{ "disabled", "enabled" }
Default:
"disabled"

Since:
3.9
@category
CompilerOptionID/**
	 * Compiler option ID: Inheritance of null annotations.
	 * <p>When enabled, the compiler will check for each method without any explicit null annotations:
	 *    If it overrides a method which has null annotations, it will treat the
	 *    current method as if it had the same annotations as the overridden method.</p>
	 * <p>Annotation inheritance will use the <em>effective</em> nullness of the overridden method
	 *    after transitively applying inheritance and after applying any default nullness
	 *    (see {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}) at the site of the overridden method.</p>
	 * <p>If different implicit null annotations (from a nonnull default and/or overridden methods) are applicable
	 *    to the same type in a method signature, this is flagged as an error 
	 *    and an explicit null annotation must be used to disambiguate.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "disabled", "enabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.9
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_INHERIT_NULL_ANNOTATIONS = JavaCore.PLUGIN_ID+".compiler.annotation.inheritNullAnnotations"; //$NON-NLS-1$
	
Compiler option ID: Reporting Dropped Nonnull Parameter Annotations.
When enabled, the compiler will issue an error or a warning against a parameter of 
   a method that overrides an inherited method
   if all of the following hold:

   
The overridden method declares the corresponding parameter as non-null (see COMPILER_NONNULL_ANNOTATION_NAME).
   
The parameter in the overriding method has no null annotation.
   
The overriding method is not affected by a nullness default (see COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME).
   
Inheritance of null annotations is disabled (see COMPILER_INHERIT_NULL_ANNOTATIONS).

This particular situation bears the same inherent risk as any unannotated method parameter,
   because the compiler's null ananysis cannot decide wither null is or is not a legal value for this parameter.
   However, the annotation in the overridden method suggests that the parameter should also be annotated as non-null.
   If that is not intended or possible, it is recommended to annotate the parameter as nullable,
   in order to make this (legal) change of contract explicit.
   

Option id:
"org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.9
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Dropped Nonnull Parameter Annotations.
	 * <p>When enabled, the compiler will issue an error or a warning against a parameter of 
	 *    a method that overrides an inherited method
	 *    if all of the following hold:</p>
	 * <ul>
	 *    <li>The overridden method declares the corresponding parameter as non-null (see {@link #COMPILER_NONNULL_ANNOTATION_NAME}).</li>
	 *    <li>The parameter in the overriding method has no null annotation.</li>
	 *    <li>The overriding method is not affected by a nullness default (see {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}).</li>
	 *    <li>Inheritance of null annotations is disabled (see {@link #COMPILER_INHERIT_NULL_ANNOTATIONS}).</li>
	 * </ul>
	 * <p>This particular situation bears the same inherent risk as any unannotated method parameter,
	 *    because the compiler's null ananysis cannot decide wither <code>null</code> is or is not a legal value for this parameter.
	 *    However, the annotation in the overridden method <em>suggests</em> that the parameter should also be annotated as non-null.
	 *    If that is not intended or possible, it is recommended to annotate the parameter as nullable,
	 *    in order to make this (legal) change of contract explicit.</p>   
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.9
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED = JavaCore.PLUGIN_ID+".compiler.problem.nonnullParameterAnnotationDropped"; //$NON-NLS-1$
	
Compiler option ID: Reporting Unsafe NonNull Interpretation Of Type Variables.
When enabled, the compiler will issue an error or a warning against a method call
   if all of the following hold:

   
The method's declared return type is a type variable without any null annotation.
   
For the given invocation this type variable is substituted with a nonnull type.
   
The type declaring the method is provided by a third-party library.
   
No null annotations exist for this library type, neither in its class file nor using external annotations.

This particular situation leverages the option to consistently substitute all occurrences of a type variable
 with a nonnull type, but it bears the risk that the library type may not be aware of null annotations thus lacking
 a necessary @Nullable annotation for a particular occurrence of a type variable.
   
This option only has an effect if the option COMPILER_ANNOTATION_NULL_ANALYSIS is enabled and when the configured set of null annotations declares the target TYPE_USE

Option id:
"org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.12
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unsafe NonNull Interpretation Of Type Variables.
	 * <p>When enabled, the compiler will issue an error or a warning against a method call
	 *    if all of the following hold:</p>
	 * <ul>
	 *    <li>The method's declared return type is a type variable without any null annotation.</li>
	 *    <li>For the given invocation this type variable is substituted with a nonnull type.</li>
	 *    <li>The type declaring the method is provided by a third-party library.</li>
	 *    <li>No null annotations exist for this library type, neither in its class file nor using external annotations.</li>
	 * </ul>
	 * <p>This particular situation leverages the option to consistently substitute all occurrences of a type variable
	 *  with a nonnull type, but it bears the risk that the library type may not be aware of null annotations thus lacking
	 *  a necessary <code>@Nullable</code> annotation for a particular occurrence of a type variable.</p>   
	 * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled and when
	 *  the configured set of null annotations declares the target <code>TYPE_USE</code></p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.12
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_NONNULL_TYPEVAR_FROM_LEGACY_INVOCATION = JavaCore.PLUGIN_ID+".compiler.problem.nonnullTypeVariableFromLegacyInvocation"; //$NON-NLS-1$

	
Compiler option ID: 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.
In source levels "1.5" and higher, the compliance and target settings should be
   set to the same version as the source level.

Option id:
"org.eclipse.jdt.core.compiler.source"
Possible values:
{ "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "9", "10", "11" }
Default:
"1.3"

See Also:
COMPILER_COMPLIANCE
COMPILER_CODEGEN_TARGET_PLATFORM
setComplianceOptions(String, Map)
Since:
2.0
@category
CompilerOptionID/**
	 * Compiler option ID: Setting Source Compatibility Mode.
	 * <p>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>.</p>
	 * <p>Source level 1.5 is necessary to enable generics, autoboxing, covariance, annotations, enumerations
	 *    enhanced for loop, static imports and varargs.</p>
	 * <p>In source levels <code>"1.5"</code> and higher, the compliance and target settings should be
	 *    set to the same version as the source level.</p>
	 * <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", "1.8", "9", "10", "11" }</code></dd>
	 * <dt>Default:</dt><dd><code>"1.3"</code></dd>
	 * </dl>
	 * @since 2.0
	 * @category CompilerOptionID
	 * @see #COMPILER_COMPLIANCE
	 * @see #COMPILER_CODEGEN_TARGET_PLATFORM
	 * @see #setComplianceOptions(String, Map)
	 */
	public static final String COMPILER_SOURCE = PLUGIN_ID + ".compiler.source"; //$NON-NLS-1$
	
Compiler option ID: Setting Compliance Level.
Select the compliance level for the compiler. COMPILER_SOURCE and COMPILER_CODEGEN_TARGET_PLATFORM settings cannot be higher than the compiler compliance level. In "1.5" and higher compliance, source and target settings
   should match the compliance setting.

Option id:
"org.eclipse.jdt.core.compiler.compliance"
Possible values:
{ "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "9", "10", "11" }
Default:
"1.4"

See Also:
COMPILER_SOURCE
COMPILER_CODEGEN_TARGET_PLATFORM
setComplianceOptions(String, Map)
Since:
2.0
@category
CompilerOptionID/**
	 * Compiler option ID: Setting Compliance Level.
	 * <p>Select the compliance level for the compiler.
	 *    {@link #COMPILER_SOURCE} and {@link #COMPILER_CODEGEN_TARGET_PLATFORM} settings cannot be
	 *    higher than the compiler compliance level. In <code>"1.5"</code> and higher compliance, source and target settings
	 *    should match the compliance setting.</p>
	 * <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", "1.8", "9", "10", "11" }</code></dd>
	 * <dt>Default:</dt><dd><code>"1.4"</code></dd>
	 * </dl>
	 * @since 2.0
	 * @category CompilerOptionID
	 * @see #COMPILER_SOURCE
	 * @see #COMPILER_CODEGEN_TARGET_PLATFORM
	 * @see #setComplianceOptions(String, Map)
	 */
	public static final String COMPILER_COMPLIANCE = PLUGIN_ID + ".compiler.compliance"; //$NON-NLS-1$
	
Compiler option ID: Use system libraries from release.
When enabled, the compiler will compile against the system libraries from release
of the specified compliance level
Setting this option sets the COMPILER_CODEGEN_TARGET_PLATFORM) and COMPILER_SOURCE to the same level as the compiler compliance. This option is available to a project only when a supporting JDK is found in the project's build path

Option id:
"org.eclipse.jdt.core.compiler.release"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.14
@category
CompilerOptionID/**
	 * Compiler option ID: Use system libraries from release.
	 * <p>When enabled, the compiler will compile against the system libraries from release
	 * of the specified compliance level</p>
	 * <p>Setting this option sets the {@link #COMPILER_CODEGEN_TARGET_PLATFORM}) and {@link #COMPILER_SOURCE} to
	 * the same level as the compiler compliance. This option is available to a project only when a supporting 
	 * JDK is found in the project's build path</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.release"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.14
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_RELEASE = PLUGIN_ID + ".compiler.release"; //$NON-NLS-1$
	
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 "NORMAL".
Task Priorities and task tags must have the same length. If task priorities are set, then task tags should also
be set.

Option id:
"org.eclipse.jdt.core.compiler.taskPriorities"
Possible values:
{ "<priority>[,<priority>]*" } where <priority> is one of "HIGH", "NORMAL" or "LOW"
Default:
"NORMAL,HIGH,NORMAL"

See Also:
COMPILER_TASK_TAGS
Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Defining the Automatic Task Priorities.
	 * <p>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>.</p>
	 * <p>Task Priorities and task tags must have the same length. If task priorities are set, then task tags should also
	 * be set.</p>
	 * <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
	 * @see #COMPILER_TASK_TAGS
	 */
	public static final String COMPILER_TASK_PRIORITIES = PLUGIN_ID + ".compiler.taskPriorities"; //$NON-NLS-1$
	
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 ("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:").
Task Priorities and task tags must have the same length. If task tags are set, then task priorities should also
be set.

Option id:
"org.eclipse.jdt.core.compiler.taskTags"
Possible values:
{ "<tag>[,<tag>]*" } where <tag> is a String without any wild-card or leading/trailing spaces
Default:
"TODO,FIXME,XXX"

See Also:
COMPILER_TASK_PRIORITIES
Since:
2.1
@category
CompilerOptionID/**
	 * Compiler option ID: Defining the Automatic Task Tags.
	 * <p>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.</p>
	 * <p>Generated task messages will start with the tag, and range until the next line separator,
	 *    comment ending, or tag.</p>
	 * <p>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.</p>
	 * <p>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>).</p>
	 * <p>Task Priorities and task tags must have the same length. If task tags are set, then task priorities should also
	 * be set.</p>
	 * <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
	 * @see #COMPILER_TASK_PRIORITIES
	 */
	public static final String COMPILER_TASK_TAGS = PLUGIN_ID + ".compiler.taskTags"; //$NON-NLS-1$
	
Compiler option ID: 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"

Since:
3.0
@category
CompilerOptionID/**
	 * Compiler option ID: Determining whether task tags are case-sensitive.
	 * <p>When enabled, task tags are considered in a case-sensitive way.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.forbiddenReference"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"error"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Forbidden Reference to Type with Restricted Access.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.forbiddenReference"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.discouragedReference"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Discouraged Reference to Type with Restricted Access.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.discouragedReference"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: 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"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Determining Effect of <code>@SuppressWarnings</code>.
	 * <p>When enabled, the <code>@SuppressWarnings</code> annotation can be used to suppress some compiler warnings.</p>
	 * <p>When disabled, all <code>@SupressWarnings</code> annotations are ignored; i.e., warnings are reported.</p>
	 * <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$
	
Compiler option ID: Raise null related errors or warnings arising because of assert statements.
When enabled, the compiler will flag all null related errors or warnings that have been enabled by the user,
   irrespective of whether a variable occurred in an assert statement.
When disabled, the compiler will not flag null related errors or warnings on variables that got marked as maybe or definitely
   null in an assert statement upstream.

Option id:
"org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.7
@category
CompilerOptionID/**
	 * Compiler option ID: Raise null related errors or warnings arising because of assert statements.
	 * <p>When enabled, the compiler will flag all null related errors or warnings that have been enabled by the user,
	 *    irrespective of whether a variable occurred in an assert statement.</p>
	 * <p>When disabled, the compiler will not flag null related errors or warnings on variables that got marked as maybe or definitely
	 *    <code>null</code> in an assert statement upstream.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.7
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS = PLUGIN_ID + ".compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$
	
Compiler option ID: Further Determining the Effect of @SuppressWarnings if also COMPILER_PB_SUPPRESS_WARNINGS is enabled. 
When enabled, the @SuppressWarnings annotation can additionally be used to suppress optional compiler diagnostics that have been configured as ERROR.
When disabled, all @SuppressWarnings annotations only affects warnings.

Option id:
"org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
3.6
@category
CompilerOptionID/**
	 * Compiler option ID: Further Determining the Effect of <code>@SuppressWarnings</code> if also
	 * {@link #COMPILER_PB_SUPPRESS_WARNINGS} is enabled.
	 * <p>When enabled, the <code>@SuppressWarnings</code> annotation can additionally be used to suppress 
	 * optional compiler diagnostics that have been configured as {@link #ERROR}.</p>
	 * <p>When disabled, all <code>@SuppressWarnings</code> annotations only affects warnings.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @since 3.6
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS = PLUGIN_ID + ".compiler.problem.suppressOptionalErrors"; //$NON-NLS-1$
	
Compiler option ID: 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", "info", "ignore" }
Default:
"warning"

Since:
3.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unhandled Warning Token for <code>@SuppressWarnings</code>.
	 * <p>When enabled, the compiler will issue an error or a warning when encountering a token
	 *    it cannot handle inside a <code>@SuppressWarnings</code> annotation.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Reporting Unnecessary @SuppressWarnings.
When enabled, the compiler will issue an error or a warning when encountering @SuppressWarnings annotation
   for which no corresponding warning got detected in the code. This diagnostic is provided to help developers to get
   rid of transient @SuppressWarnings no longer needed. Note that @SuppressWarnings("all") is still
   silencing the warning for unnecessary @SuppressWarnings, as it is the master switch to silence ALL warnings.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedWarningToken"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.4
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Unnecessary <code>@SuppressWarnings</code>.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedWarningToken"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.
Assert statements are ignored unless COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.problem.nullReference"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.2
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Null Dereference.
	 * <p>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.</p>
	 * <p>Assert statements are ignored unless {@link #COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS}
	 *    is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullReference"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.
Assert statements are ignored unless COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.problem.potentialNullReference"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.3
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Potential Null Dereference.
	 * <p>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.</p>
	 * <p>Assert statements are ignored unless {@link #COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS}
	 *    is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.potentialNullReference"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.
Assert statements are ignored unless COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS is enabled.

Option id:
"org.eclipse.jdt.core.compiler.problem.redundantNullCheck"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.3
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Redundant Null Check.
	 * <p>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.</p>
	 * <p>Assert statements are ignored unless {@link #COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS}
	 *    is enabled.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantNullCheck"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.3
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Overriding method that doesn't call the super method invocation.
	 * <p>When enabled, the compiler will issue an error or a warning if a method is overriding a method without calling
	 *    the super invocation.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
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.

Option id:
"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.4
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Redundant Superinterface.
	 * <p>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.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "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$
	
Compiler option ID: Reporting Comparison of Identical Expressions.
When enabled, the compiler will issue an error or a warning if a comparison
is involving identical operands (e.g 'x == x').

Option id:
"org.eclipse.jdt.core.compiler.problem.comparingIdentical"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"warning"

Since:
3.5
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Comparison of Identical Expressions.
	 * <p>When enabled, the compiler will issue an error or a warning if a comparison
	 * is involving identical operands (e.g <code>'x == x'</code>).</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.comparingIdentical"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @since 3.5
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_COMPARING_IDENTICAL = PLUGIN_ID + ".compiler.problem.comparingIdentical"; //$NON-NLS-1$
	
Compiler option ID: Reporting Missing Synchronized Modifier On Inherited Method.
When enabled, the compiler will issue an error or a warning if a method
overrides a synchronized method without having a synchronized modifier.

Option id:
"org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.5
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Missing Synchronized Modifier On Inherited Method.
	 * <p>When enabled, the compiler will issue an error or a warning if a method
	 * overrides a synchronized method without having a synchronized modifier.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.5
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD = PLUGIN_ID + ".compiler.problem.missingSynchronizedOnInheritedMethod"; //$NON-NLS-1$
	
Compiler option ID: Reporting Allocation of an Unused Object.
When enabled, the compiler will issue an error or a warning if an object is allocated but never used,
neither by holding a reference nor by invoking one of the object's methods.

Option id:
"org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.6
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting Allocation of an Unused Object.
	 * <p>When enabled, the compiler will issue an error or a warning if an object is allocated but never used,
	 * neither by holding a reference nor by invoking one of the object's methods.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.6
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_UNUSED_OBJECT_ALLOCATION = PLUGIN_ID + ".compiler.problem.unusedObjectAllocation";  //$NON-NLS-1$
	
Compiler option ID: Reporting redundant specification of type arguments in class instance creation expressions.
When enabled, the compiler will issue an error or a warning if type arguments are used in a class instance creation,
when the '<>' operator can be used instead.
This option only has an effect if the compiler compliance is 1.7 or greater.

Option id:
"org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments"
Possible values:
{ "error", "warning", "info", "ignore" }
Default:
"ignore"

Since:
3.7.1
@category
CompilerOptionID/**
	 * Compiler option ID: Reporting redundant specification of type arguments in class instance creation expressions.
	 * <p>When enabled, the compiler will issue an error or a warning if type arguments are used in a class instance creation,
	 * when the '&lt;&gt;' operator can be used instead.</p>
	 * <p>This option only has an effect if the compiler compliance is 1.7 or greater.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"ignore"</code></dd>
	 * </dl>
	 * @since 3.7.1
	 * @category CompilerOptionID
	 */
	public static final String COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS = PLUGIN_ID + ".compiler.problem.redundantSpecificationOfTypeArguments";  //$NON-NLS-1$
	
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).

Option id:
"org.eclipse.jdt.core.computeJavaBuildOrder"
Possible values:
{ "compute", "ignore" }
Default:
"ignore"

@category
CoreOptionID/**
	 * Core option ID: Computing Project Build Order.
	 * <p>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).</p>
	 * <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$
	
Core option ID: Specifying Filters for Resource Copying Control.
Allow to specify some filters to control the resource copy process.

Option id:
"org.eclipse.jdt.core.builder.resourceCopyExclusionFilter"
Possible values:
{ "<name>[,<name>]* } where <name> is a file name pattern (* and ? wild-cards allowed)
   or the name of a folder which ends with '/'
Default:
""

Since:
2.0
@category
CoreOptionID/**
	 * Core option ID: Specifying Filters for Resource Copying Control.
	 * <p>Allow to specify some filters to control the resource copy process.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.builder.duplicateResourceTask"
Possible values:
{ "error", "warning" }
Default:
"warning"

Since:
2.1
@category
CoreOptionID/**
	 * Core option ID: Reporting Duplicate Resources.
	 * <p>Indicate the severity of the problem reported when more than one occurrence
	 *    of a resource is to be copied into the output location.</p>
	 * <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$
	
Core option ID: 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"

Since:
2.1
@category
CoreOptionID/**
	 * Core option ID: Cleaning Output Folder(s).
	 * <p>Indicate whether the JavaBuilder is allowed to clean the output folders
	 *    when performing full build operations.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder"
Possible values:
{ "enabled", "ignore" }
Default:
"ignore"

Since:
3.2
@category
CoreOptionID/**
	 * Core option ID: Recreate Modified class files in Output Folder.
	 * <p>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.</p>
	 * <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$
	
Core option ID: Reporting Incomplete Classpath.
Indicate the severity of the problem reported when an entry on the classpath does not exist,
   is not legitimate or is not visible (for example, a referenced project is closed).

Option id:
"org.eclipse.jdt.core.incompleteClasspath"
Possible values:
{ "error", "warning"}
Default:
"error"

Since:
2.1
@category
CoreOptionID/**
	 * Core option ID: Reporting Incomplete Classpath.
	 * <p>Indicate the severity of the problem reported when an entry on the classpath does not exist,
	 *    is not legitimate or is not visible (for example, a referenced project is closed).</p>
	 * <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$
	
Core option ID: 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"

Since:
2.1
@category
CoreOptionID/**
	 * Core option ID: Reporting Classpath Cycle.
	 * <p>Indicate the severity of the problem reported when a project is involved in a cycle.</p>
	 * <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$
	
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).

Option id:
"org.eclipse.jdt.core.incompatibleJDKLevel"
Possible values:
{ "error", "warning", "ignore" }
Default:
"ignore"

Since:
3.0
@category
CoreOptionID/**
	 * Core option ID: Reporting Incompatible JDK Level for Required Binaries.
	 * <p>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).</p>
	 * <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$
	
Core option ID: 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"

Since:
2.0
@category
CoreOptionID/**
	 * Core option ID: Abort if Invalid Classpath.
	 * <p>Allow to toggle the builder to abort if the classpath is invalid.</p>
	 * <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$
	
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 ResourcesPlugin.getEncoding().
It is offered as a convenience shortcut only.

Option id:
"org.eclipse.jdt.core.encoding"
value:
<immutable, platform default value>

Since:
2.0
@category
CoreOptionID/**
	 * Core option ID: Default Source Encoding Format.
	 * <p>Get the default encoding format of source files. This value is
	 *    immutable and preset to the result of <code>ResourcesPlugin.getEncoding()</code>.</p>
	 * <p>It is offered as a convenience shortcut only.</p>
	 * <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$
	
Core option ID: 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"

Since:
2.1
@category
CoreOptionID/**
	 * Core option ID: Enabling Usage of Classpath Exclusion Patterns.
	 * <p>When disabled, no entry on a project classpath can be associated with
	 *    an exclusion pattern.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.classpath.multipleOutputLocations"
Possible values:
{ "enabled", "disabled" }
Default:
"enabled"

Since:
2.1
@category
CoreOptionID/**
	 * Core option ID: Enabling Usage of Classpath Multiple Output Locations.
	 * <p>When disabled, no entry on a project classpath can be associated with
	 *    a specific output location, preventing thus usage of multiple output locations.</p>
	 * <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$
	
Core option ID: Reporting an output location overlapping another source location.
 Indicate the severity of the problem reported when a source entry's output location overlaps another
source entry.

Option id:
"org.eclipse.jdt.core.classpath.outputOverlappingAnotherSource"
Possible values:
{ "error", "warning", "ignore" }
Default:
"error"

Since:
3.6.4/**
	 * Core option ID: Reporting an output location overlapping another source location.
	 * <p> Indicate the severity of the problem reported when a source entry's output location overlaps another
	 * source entry.</p>
	 * 
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.classpath.outputOverlappingAnotherSource"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"error"</code></dd>
	 * </dl>
	 * @since 3.6.4
	 */
	public static final String CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE = PLUGIN_ID + ".classpath.outputOverlappingAnotherSource";  //$NON-NLS-1$

	
Core option ID: Reporting if a project which has only main sources depends on a project with only test sources.
 Indicate the severity of the problem reported when a project that has one or more main source folders but 
no test source folders has a project on its build path that only has one or more test source folders, but no main source folders.

Option id:
"org.eclipse.jdt.core.classpath.mainOnlyProjectHasTestOnlyDependency"
Possible values:
{ "error", "ignore" }
Default:
"error"

Since:
3.16/**
	 * Core option ID: Reporting if a project which has only main sources depends on a project with only test sources.
	 * <p> Indicate the severity of the problem reported when a project that has one or more main source folders but 
	 * no test source folders has a project on its build path that only has one or more test source folders, but no main source folders.</p>
	 * 
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.classpath.mainOnlyProjectHasTestOnlyDependency"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "error", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"error"</code></dd>
	 * </dl>
	 * @since 3.16
	 */
	public static final String CORE_MAIN_ONLY_PROJECT_HAS_TEST_ONLY_DEPENDENCY = PLUGIN_ID + ".classpath.mainOnlyProjectHasTestOnlyDependency";  //$NON-NLS-1$

	
Compiler option ID: Enabling support for preview language features.
When enabled, the compiler will activate the preview language features of this Java version.

Option id:
"org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

@category
CompilerOptionID
Since:
3.18/**
	 * Compiler option ID: Enabling support for preview language features.
	 * <p>When enabled, the compiler will activate the preview language features of this Java version.</p>
	 *
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"disabled"</code></dd>
	 * </dl>
	 * @category CompilerOptionID
	 * @since 3.18
	 */
	public static final String COMPILER_PB_ENABLE_PREVIEW_FEATURES = PLUGIN_ID + ".compiler.problem.enablePreviewFeatures"; //$NON-NLS-1$
	
Compiler option ID: Reporting Preview features.
When enabled, the compiler will issue a warning when a preview feature is used.

Option id:
"org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures"
Possible values:
{ "warning", "info", "ignore" }
Default:
"warning"

@category
CompilerOptionID
Since:
3.18/**
	 * Compiler option ID: Reporting Preview features.
	 * <p>When enabled, the compiler will issue a warning when a preview feature is used.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "warning", "info", "ignore" }</code></dd>
	 * <dt>Default:</dt><dd><code>"warning"</code></dd>
	 * </dl>
	 * @category CompilerOptionID
	 * @since 3.18
	 */
	public static final String COMPILER_PB_REPORT_PREVIEW_FEATURES = PLUGIN_ID + ".compiler.problem.reportPreviewFeatures"; //$NON-NLS-1$
	
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 0, the parameter names are not fetched and the raw names are returned.

Option id:
"org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc"
Possible values:
"<n>", where n is an integer greater than or equal to 0
Default:
"50"

Since:
3.2
@category
CoreOptionID/**
	 * Core option ID: Set the timeout value for retrieving the method's parameter names from javadoc.
	 * <p>Timeout in milliseconds to retrieve the method's parameter names from javadoc.</p>
	 * <p>If the value is <code>0</code>, the parameter names are not fetched and the raw names are returned.</p>
	 * <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 TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC = PLUGIN_ID + ".timeoutForParameterNameFromAttachedJavadoc"; //$NON-NLS-1$

	
Core option ID: The ID of the formatter to use in formatting operations.

Option id:
"org.eclipse.jdt.core.javaFormatter"
Default:
"org.eclipse.jdt.core.defaultJavaFormatter"

See Also:
DEFAULT_JAVA_FORMATTER
JAVA_FORMATTER_EXTENSION_POINT_ID
Since:
3.11
@category
CoreOptionID/**
	 * Core option ID: The ID of the formatter to use in formatting operations.
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.javaFormatter"</code></dd>
	 * <dt>Default:</dt><dd><code>"org.eclipse.jdt.core.defaultJavaFormatter"</code></dd>
	 * </dl>
	 * @see #DEFAULT_JAVA_FORMATTER
	 * @see #JAVA_FORMATTER_EXTENSION_POINT_ID
	 * @since 3.11
	 * @category CoreOptionID
	 */
	public static final String JAVA_FORMATTER = PLUGIN_ID + ".javaFormatter"; //$NON-NLS-1$

	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION, DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK , DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION, DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION, DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_SWITCH, DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION instead.
@category
DeprecatedOptionID/**
	 * @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.
	 * @category DeprecatedOptionID
	 */
	public static final String FORMATTER_NEWLINE_OPENING_BRACE = PLUGIN_ID + ".formatter.newline.openingBrace"; //$NON-NLS-1$
	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT, DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT, DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT, DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT instead.
@category
DeprecatedOptionID/**
	 * @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$
	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_COMPACT_ELSE_IF instead.
@category
DeprecatedOptionID/**
	 * @since 2.0
	 * @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$
	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK instead.
@category
DeprecatedOptionID/**
	 * @since 2.0
	 * @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$
	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE instead.
@category
DeprecatedOptionID/**
	 * @since 2.0
	 * @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$
	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_LINE_SPLIT instead
@category
DeprecatedOptionID/**
	 * @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$
	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR instead.
@category
DeprecatedOptionID/**
	 * @since 2.0
	 * @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$
	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR instead.
@category
DeprecatedOptionID/**
	 * @since 2.0
	 * @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$
	
Since:
2.0
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE instead.
@category
DeprecatedOptionID/**
	 * @since 2.0
	 * @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$
	
Since:
2.1
Deprecated:
Use DefaultCodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST instead.
@category
DeprecatedOptionID/**
	 * @since 2.1
	 * @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$
	
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).

Option id:
"org.eclipse.jdt.core.codeComplete.visibilityCheck"
Possible values:
{ "enabled", "disabled" }
Default:
"disabled"

Since:
2.0
@category
CodeAssistOptionID/**
	 * Code assist option ID: Activate Visibility Sensitive Completion.
	 * <p>When active, completion doesn't show that you can not see
	 *    (for example, you can not see private methods of a super class).</p>
	 * <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$
	
Code assist option ID: 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"

Since:
3.2
@category
CodeAssistOptionID/**
	 * Code assist option ID: Activate Deprecation Sensitive Completion.
	 * <p>When enabled, completion doesn't propose deprecated members and types.</p>
	 * <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$
	
Code assist option ID: 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"

Since:
3.2
@category
CodeAssistOptionID/**
	 * Code assist option ID: Activate Camel Case Sensitive Completion.
	 * <p>When enabled, completion shows proposals whose name match the CamelCase
	 *    pattern.</p>
	 * <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$
	
Code assist option ID: Activate Substring Code Completion.
When enabled, completion shows proposals in which the pattern can
   be found as a substring in a case-insensitive way.

Option id:
"org.eclipse.jdt.core.codeComplete.substringMatch"
Possible values:
{ "enabled", "disabled" }
Default:
"enabled"

Since:
3.12
@category
CodeAssistOptionID/**
	 * Code assist option ID: Activate Substring Code Completion.
	 * <p>When enabled, completion shows proposals in which the pattern can
	 *    be found as a substring in a case-insensitive way.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.substringMatch"</code></dd>
	 * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd>
	 * <dt>Default:</dt><dd><code>"enabled"</code></dd>
	 * </dl>
	 * @since 3.12
	 * @category CodeAssistOptionID
	 */
	public static final String CODEASSIST_SUBSTRING_MATCH = PLUGIN_ID + ".codeComplete.substringMatch"; //$NON-NLS-1$
	
Code assist option ID: 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"

Since:
2.0
@category
CodeAssistOptionID/**
	 * Code assist option ID: Automatic Qualification of Implicit Members.
	 * <p>When active, completion automatically qualifies completion on implicit
	 *    field references and message expressions.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.codeComplete.fieldPrefixes"
Possible values:
{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
Default:
""

Since:
2.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Prefixes for Field Name.
	 * <p>When the prefixes is non empty, completion for field name will begin with
	 *    one of the proposed prefixes.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.codeComplete.staticFieldPrefixes"
Possible values:
{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
Default:
""

Since:
2.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Prefixes for Static Field Name.
	 * <p>When the prefixes is non empty, completion for static field name will begin with
	 *    one of the proposed prefixes.</p>
	 * <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$
	
Code assist option ID: Define the Prefixes for Static Final Field Name.
When the prefixes is non empty, completion for static final field name will begin with
   one of the proposed prefixes.

Option id:
"org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes"
Possible values:
{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
Default:
""

Since:
3.5
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Prefixes for Static Final Field Name.
	 * <p>When the prefixes is non empty, completion for static final field name will begin with
	 *    one of the proposed prefixes.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes"</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 3.5
	 * @category CodeAssistOptionID
	 */
	public static final String CODEASSIST_STATIC_FINAL_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFinalFieldPrefixes"; //$NON-NLS-1$
	
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.

Option id:
"org.eclipse.jdt.core.codeComplete.localPrefixes"
Possible values:
{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
Default:
""

Since:
2.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Prefixes for Local Variable Name.
	 * <p>When the prefixes is non empty, completion for local variable name will begin with
	 *    one of the proposed prefixes.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.codeComplete.argumentPrefixes"
Possible values:
{ "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
Default:
""

Since:
2.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Prefixes for Argument Name.
	 * <p>When the prefixes is non empty, completion for argument name will begin with
	 *    one of the proposed prefixes.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.codeComplete.fieldSuffixes"
Possible values:
{ "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
Default:
""

Since:
2.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Suffixes for Field Name.
	 * <p>When the suffixes is non empty, completion for field name will end with
	 *    one of the proposed suffixes.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.codeComplete.staticFieldSuffixes"
Possible values:
{ "<suffix>[,<suffix>]*" }< where <suffix> is a String without any wild-card
Default:
""

Since:
2.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Suffixes for Static Field Name.
	 * <p>When the suffixes is non empty, completion for static field name will end with
	 *    one of the proposed suffixes.</p>
	 * <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$
	
Code assist option ID: Define the Suffixes for Static Final Field Name.
When the suffixes is non empty, completion for static final field name will end with
   one of the proposed suffixes.

Option id:
"org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes"
Possible values:
{ "<suffix>[,<suffix>]*" }< where <suffix> is a String without any wild-card
Default:
""

Since:
3.5
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Suffixes for Static Final Field Name.
	 * <p>When the suffixes is non empty, completion for static final field name will end with
	 *    one of the proposed suffixes.</p>
	 * <dl>
	 * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes"</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 3.5
	 * @category CodeAssistOptionID
	 */
	public static final String CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFinalFieldSuffixes"; //$NON-NLS-1$
	
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.

Option id:
"org.eclipse.jdt.core.codeComplete.localSuffixes"
Possible values:
{ "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
Default:
""

Since:
2.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Suffixes for Local Variable Name.
	 * <p>When the suffixes is non empty, completion for local variable name will end with
	 *    one of the proposed suffixes.</p>
	 * <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$
	
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.

Option id:
"org.eclipse.jdt.core.codeComplete.argumentSuffixes"
Possible values:
{ "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
Default:
""

Since:
2.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Define the Suffixes for Argument Name.
	 * <p>When the suffixes is non empty, completion for argument name will end with
	 *    one of the proposed suffixes.</p>
	 * <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$
	
Code assist option ID: 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"

Since:
3.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Activate Forbidden Reference Sensitive Completion.
	 * <p>When enabled, completion doesn't propose elements which match a
	 *    forbidden reference rule.</p>
	 * <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$
	
Code assist option ID: 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"

Since:
3.1
@category
CodeAssistOptionID/**
	 * Code assist option ID: Activate Discouraged Reference Sensitive Completion.
	 * <p>When enabled, completion doesn't propose elements which match a
	 *    discouraged reference rule.</p>
	 * <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$
	
Code assist option ID: 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"

Since:
3.3
@category
CodeAssistOptionID/**
	 * Code assist option ID: Activate Suggestion of Static Import.
	 * <p>When enabled, completion proposals can contain static import
	 *    pattern.</p>
	 * <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 {
	
Deprecated:
Use DEFAULT_TASK_TAGS instead.
Since:
2.1
@category
DeprecatedOptionValue/**
	 * @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 DEFAULT_TASK_PRIORITIES instead.
Since:
2.1
@category
DeprecatedOptionValue/**
	 * @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: "TODO,FIXME,XXX". 
Since:
3.0
@category
OptionValue/**
	 * 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: "NORMAL,HIGH,NORMAL". 
Since:
3.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.0
	 * @category OptionValue
	 */
	public static final String DEFAULT_TASK_PRIORITIES = "NORMAL,HIGH,NORMAL"; //$NON-NLS-1$
	
Configurable option value: "generate". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String GENERATE = "generate"; //$NON-NLS-1$
	
Configurable option value: "do not generate". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String DO_NOT_GENERATE = "do not generate"; //$NON-NLS-1$
	
Configurable option value: "preserve". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String PRESERVE = "preserve"; //$NON-NLS-1$
	
Configurable option value: "optimize out". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String OPTIMIZE_OUT = "optimize out"; //$NON-NLS-1$
	
Configurable option value for COMPILER_TASK_PRIORITIES: "HIGH". 
Since:
2.1
@category
OptionValue/**
	 * 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 COMPILER_TASK_PRIORITIES: "LOW". 
Since:
2.1
@category
OptionValue/**
	 * 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 COMPILER_TASK_PRIORITIES: "NORMAL". 
Since:
2.1
@category
OptionValue/**
	 * 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: "1.1". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String VERSION_1_1 = "1.1"; //$NON-NLS-1$
	
Configurable option value: "1.2". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String VERSION_1_2 = "1.2"; //$NON-NLS-1$
	
Configurable option value: "1.3". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String VERSION_1_3 = "1.3"; //$NON-NLS-1$
	
Configurable option value: "1.4". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String VERSION_1_4 = "1.4"; //$NON-NLS-1$
	
Configurable option value: "1.5". 
Since:
3.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.0
	 * @category OptionValue
	 */
	public static final String VERSION_1_5 = "1.5"; //$NON-NLS-1$
	
Configurable option value: "1.6". 
Since:
3.2
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.2
	 * @category OptionValue
	 */
	public static final String VERSION_1_6 = "1.6"; //$NON-NLS-1$
	
Configurable option value: "1.7". 
Since:
3.3
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.3
	 * @category OptionValue
	 */
	public static final String VERSION_1_7 = "1.7"; //$NON-NLS-1$
	
Configurable option value: "1.8". 
Since:
3.10
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.10
	 * @category OptionValue
	 */
	public static final String VERSION_1_8 = "1.8"; //$NON-NLS-1$
	
Configurable option value: "9". 
Since:
3.14
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.14
	 * @category OptionValue
	 */
	public static final String VERSION_9 = "9"; //$NON-NLS-1$
	
Configurable option value: "10". 
Since:
3.14
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.14
	 * @category OptionValue
	 */
	public static final String VERSION_10 = "10"; //$NON-NLS-1$
	
Configurable option value: "11". 
Since:
3.16
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.16
	 * @category OptionValue
	 */
	public static final String VERSION_11 = "11"; //$NON-NLS-1$
	
Configurable option value: "12". 
Since:
3.18
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.18
	 * @category OptionValue
	 */
	public static final String VERSION_12 = "12"; //$NON-NLS-1$
	
Configurable option value: "13". 
Since:
3.20
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.20
	 * @category OptionValue
	 */
	public static final String VERSION_13 = "13"; //$NON-NLS-1$
	
Configurable option value: "cldc1.1". 
Since:
3.4
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.4
	 * @category OptionValue
	 */
	public static final String VERSION_CLDC_1_1 = "cldc1.1"; //$NON-NLS-1$
	private static List<String> allVersions = Collections.unmodifiableList(Arrays.asList(VERSION_CLDC_1_1, VERSION_1_1, VERSION_1_2, VERSION_1_3, VERSION_1_4, VERSION_1_5,
			VERSION_1_6, VERSION_1_7, VERSION_1_8, VERSION_9, VERSION_10, VERSION_11, VERSION_12, VERSION_13));

	
Returns all JavaCore#VERSION_* levels in the order of their introduction. For e.g., VERSION_1_8 appears before VERSION_10 
Returns:
all available versions
Since:
3.14/**
	 * Returns all {@link JavaCore}{@code #VERSION_*} levels in the order of their 
	 * introduction. For e.g., {@link JavaCore#VERSION_1_8} appears before {@link JavaCore#VERSION_10}
	 * 
	 * @return all available versions
	 * @since 3.14
	 */
	public static List<String> getAllVersions() {
		return allVersions;
	}

	
Returns whether the given version of Java or Java Runtime is supported 
by the Java Development Toolkit.
A true indicates that the given version is supported. For e.g., if the argument
is 11.0.1 and getAllVersions() contains 11, 
the method returns true.
Returns:
a boolean indicating support for the given version of Java or Java Runtime.
Since:
3.16/**
	 * Returns whether the given version of Java or Java Runtime is supported 
	 * by the Java Development Toolkit.
	 * 
	 * A true indicates that the given version is supported. For e.g., if the argument
	 * is <code>11.0.1</code> and {@link #getAllVersions()} contains <code>11</code>, 
	 * the method returns <code>true</code>.
	 * 
	 * @return a boolean indicating support for the given version of Java or Java Runtime.
	 * @since 3.16
	 */
	public static boolean isSupportedJavaVersion(String version) {
		return CompilerOptions.versionToJdkLevel(version, false) > 0;
	}

	
Configurable option value: "abort". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String ABORT = "abort"; //$NON-NLS-1$
	
Configurable option value: "error". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String ERROR = "error"; //$NON-NLS-1$
	
Configurable option value: "warning". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String WARNING = "warning"; //$NON-NLS-1$
	
Configurable option value: "ignore". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String IGNORE = "ignore"; //$NON-NLS-1$
	
Configurable option value: "info". 
@category
OptionValue
Since:
3.12/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 * @since 3.12
	 */
	public static final String INFO = "info"; //$NON-NLS-1$
	
Configurable option value: "compute". 
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @category OptionValue
	 */
	public static final String COMPUTE = "compute"; //$NON-NLS-1$
	
Configurable option value: "insert". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String INSERT = "insert"; //$NON-NLS-1$
	
Configurable option value: "do not insert". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String DO_NOT_INSERT = "do not insert"; //$NON-NLS-1$
	
Configurable option value: "preserve one". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String PRESERVE_ONE = "preserve one"; //$NON-NLS-1$
	
Configurable option value: "clear all". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String CLEAR_ALL = "clear all"; //$NON-NLS-1$
	
Configurable option value: "normal". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String NORMAL = "normal"; //$NON-NLS-1$
	
Configurable option value: "compact". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String COMPACT = "compact"; //$NON-NLS-1$
	
Configurable option value: "tab". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String TAB = "tab"; //$NON-NLS-1$
	
Configurable option value: "space". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String SPACE = "space"; //$NON-NLS-1$
	
Configurable option value: "enabled". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String ENABLED = "enabled"; //$NON-NLS-1$
	
Configurable option value: "disabled". 
Since:
2.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.0
	 * @category OptionValue
	 */
	public static final String DISABLED = "disabled"; //$NON-NLS-1$
	
Configurable option value: "clean". 
Since:
2.1
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 2.1
	 * @category OptionValue
	 */
	public static final String CLEAN = "clean"; //$NON-NLS-1$
	
Configurable option value: "public". 
Since:
3.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.0
	 * @category OptionValue
	 */
	public static final String PUBLIC = "public"; //$NON-NLS-1$
	
Configurable option value: "protected". 
Since:
3.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.0
	 * @category OptionValue
	 */
	public static final String PROTECTED = "protected"; //$NON-NLS-1$
	
Configurable option value: "default". 
Since:
3.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.0
	 * @category OptionValue
	 */
	public static final String DEFAULT = "default"; //$NON-NLS-1$
	
Configurable option value: "private". 
Since:
3.0
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.0
	 * @category OptionValue
	 */
	public static final String PRIVATE = "private"; //$NON-NLS-1$
	
Configurable option value: "never". 
Since:
3.1
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.1
	 * @category OptionValue
	 */
	public static final String NEVER = "never"; //$NON-NLS-1$
	
Configurable option value: "no_tag". 
Since:
3.4
@category
OptionValue/**
	 * 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: "return_tag". 
Since:
3.4
@category
OptionValue/**
	 * 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: "all_standard_tags". 
Since:
3.4
@category
OptionValue/**
	 * Configurable option value: {@value}.
	 * @since 3.4
	 * @category OptionValue
	 */
	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_STANDARD_TAGS = CompilerOptions.ALL_STANDARD_TAGS;
	// end configurable option values }

	
Value of the content-type for Java source files. Use this value to retrieve the Java content type
from the content type manager, and to add new Java-like extensions to this content type.
See Also:
getContentType.getContentType(String)
getJavaLikeExtensions()
Since:
3.2/**
	 * Value of the content-type for Java source files. Use this value to retrieve the Java content type
	 * from the content type manager, and to add new Java-like extensions to this content type.
	 *
	 * @see org.eclipse.core.runtime.content.IContentTypeManager#getContentType(String)
	 * @see #getJavaLikeExtensions()
	 * @since 3.2
	 */
	public static final String JAVA_SOURCE_CONTENT_TYPE = JavaCore.PLUGIN_ID+".javaSource" ; //$NON-NLS-1$

	
The ID of the Eclipse built-in formatter.
See Also:
JAVA_FORMATTER
JAVA_FORMATTER_EXTENSION_POINT_ID
Since:
3.11/**
	 * The ID of the Eclipse built-in formatter.
	 *
	 * @see #JAVA_FORMATTER
	 * @see #JAVA_FORMATTER_EXTENSION_POINT_ID
	 * @since 3.11
	 */
	public static final String DEFAULT_JAVA_FORMATTER = PLUGIN_ID + ".defaultJavaFormatter"; //$NON-NLS-1$

	
Name of the extension point for contributing a source code formatter
See Also:
JAVA_FORMATTER
DEFAULT_JAVA_FORMATTER
Since:
3.11/**
	 * Name of the extension point for contributing a source code formatter
	 * @see #JAVA_FORMATTER
	 * @see #DEFAULT_JAVA_FORMATTER
	 * @since 3.11
	 */
	public static final String JAVA_FORMATTER_EXTENSION_POINT_ID = "javaFormatter" ;  //$NON-NLS-1$

	
Creates the Java core plug-in.

The plug-in instance is created automatically by the
Eclipse platform. Clients must not call.

Since:
3.0/**
	 * Creates the Java core plug-in.
	 * <p>
	 * The plug-in instance is created automatically by the
	 * Eclipse platform. Clients must not call.
	 * </p>
	 *
	 * @since 3.0
	 */
	public JavaCore() {
		super();
		JAVA_CORE_PLUGIN = this;
	}

	
Adds the given listener for changes to Java elements.
Has no effect if an identical listener is already registered.

This listener will only be notified during the POST_CHANGE resource change notification
and any reconcile operation (POST_RECONCILE).


For finer control of the notification, use addElementChangedListener(IElementChangedListener,int),
which allows to specify a different eventMask.

Params:
listener – the listener
See Also:
ElementChangedEvent/**
	 * Adds the given listener for changes to Java elements.
	 * Has no effect if an identical listener is already registered.
	 * <p>
	 * This listener will only be notified during the POST_CHANGE resource change notification
	 * and any reconcile operation (POST_RECONCILE).
	 * </p>
	 * <p>
	 * For finer control of the notification, use <code>addElementChangedListener(IElementChangedListener,int)</code>,
	 * which allows to specify a different eventMask.
	 * </p>
	 *
	 * @param listener the listener
	 * @see ElementChangedEvent
	 */
	public static void addElementChangedListener(IElementChangedListener listener) {
		addElementChangedListener(listener, ElementChangedEvent.POST_CHANGE | ElementChangedEvent.POST_RECONCILE);
	}

	
Adds the given listener for changes to Java elements.
Has no effect if an identical listener is already registered.
After completion of this method, the given listener will be registered for exactly
the specified events.  If they were previously registered for other events, they
will be deregistered.

Once registered, a listener starts receiving notification of changes to
java elements in the model. The listener continues to receive
notifications until it is replaced or removed.


Listeners can listen for several types of event as defined in ElementChangeEvent.
Clients are free to register for any number of event types however if they register
for more than one, it is their responsibility to ensure they correctly handle the
case where the same java element change shows up in multiple notifications.
Clients are guaranteed to receive only the events for which they are registered.

Params:
listener – the listener
eventMask – the bit-wise OR of all event types of interest to the listener
See Also:
IElementChangedListener
ElementChangedEvent
removeElementChangedListener(IElementChangedListener)
Since:
2.0/**
	 * Adds the given listener for changes to Java elements.
	 * Has no effect if an identical listener is already registered.
	 * After completion of this method, the given listener will be registered for exactly
	 * the specified events.  If they were previously registered for other events, they
	 * will be deregistered.
	 * <p>
	 * Once registered, a listener starts receiving notification of changes to
	 * java elements in the model. The listener continues to receive
	 * notifications until it is replaced or removed.
	 * </p>
	 * <p>
	 * Listeners can listen for several types of event as defined in <code>ElementChangeEvent</code>.
	 * Clients are free to register for any number of event types however if they register
	 * for more than one, it is their responsibility to ensure they correctly handle the
	 * case where the same java element change shows up in multiple notifications.
	 * Clients are guaranteed to receive only the events for which they are registered.
	 * </p>
	 *
	 * @param listener the listener
	 * @param eventMask the bit-wise OR of all event types of interest to the listener
	 * @see IElementChangedListener
	 * @see ElementChangedEvent
	 * @see #removeElementChangedListener(IElementChangedListener)
	 * @since 2.0
	 */
	public static void addElementChangedListener(IElementChangedListener listener, int eventMask) {
		JavaModelManager.getDeltaState().addElementChangedListener(listener, eventMask);
	}

	
Configures the given marker attribute map for the given Java element.
Used for markers, which denote a Java element rather than a resource.
Params:
attributes – the mutable marker attribute map (key type: String,
  value type: String)
element – the Java element for which the marker needs to be configured/**
	 * Configures the given marker attribute map for the given Java element.
	 * Used for markers, which denote a Java element rather than a resource.
	 *
	 * @param attributes the mutable marker attribute map (key type: <code>String</code>,
	 *   value type: <code>String</code>)
	 * @param element the Java element for which the marker needs to be configured
	 */
	public static void addJavaElementMarkerAttributes(
		Map attributes,
		IJavaElement element) {
		if (element instanceof IMember)
			element = ((IMember) element).getClassFile();
		if (attributes != null && element != null)
			attributes.put(ATT_HANDLE_ID, element.getHandleIdentifier());
	}

	private static void addNonJavaResources(Object[] nonJavaResources,
			IContainer container,
			int rootPathSegmentCounts,
			ArrayList collector) {
		for (int i = 0, max = nonJavaResources.length; i < max; i++) {
			Object nonJavaResource = nonJavaResources[i];
			if (nonJavaResource instanceof IFile) {
				IFile file = (IFile) nonJavaResource;
				IPath path = file.getFullPath().removeFirstSegments(rootPathSegmentCounts);
				IResource member = container.findMember(path);
				if (member != null && member.exists()) {
					collector.add(member);
				}
			} else if (nonJavaResource instanceof IFolder) {
				IFolder folder = (IFolder) nonJavaResource;
				IResource[] members = null;
				try {
					members = folder.members();
				} catch (CoreException e) {
					// ignore
				}
				if (members != null) {
					addNonJavaResources(members, container, rootPathSegmentCounts, collector);
				}
			}
		}
	}

	
Adds the given listener for POST_CHANGE resource change events to the Java core.
The listener is guaranteed to be notified of the POST_CHANGE resource change event before
the Java core starts processing the resource change event itself.

Has no effect if an identical listener is already registered.

Params:
listener – the listener
See Also:
removePreProcessingResourceChangedListener(IResourceChangeListener)
Since:
3.0
Deprecated:
use addPreProcessingResourceChangedListener(listener, IResourceChangeEvent.POST_CHANGE) instead/**
	 * Adds the given listener for POST_CHANGE resource change events to the Java core.
	 * The listener is guaranteed to be notified of the POST_CHANGE resource change event before
	 * the Java core starts processing the resource change event itself.
	 * <p>
	 * Has no effect if an identical listener is already registered.
	 * </p>
	 *
	 * @param listener the listener
	 * @see #removePreProcessingResourceChangedListener(IResourceChangeListener)
	 * @since 3.0
	 * @deprecated use addPreProcessingResourceChangedListener(listener, IResourceChangeEvent.POST_CHANGE) instead
	 */
	public static void addPreProcessingResourceChangedListener(IResourceChangeListener listener) {
		addPreProcessingResourceChangedListener(listener, IResourceChangeEvent.POST_CHANGE);
	}

	
Adds the given listener for resource change events of the given types to the Java core.
The listener is guaranteed to be notified of the resource change event before
the Java core starts processing the resource change event itself.

If an identical listener is already registered, the given event types are added to the event types
of interest to the listener.


Supported event types are:


IResourceChangeEvent.PRE_BUILD
IResourceChangeEvent.POST_BUILD
IResourceChangeEvent.POST_CHANGE
IResourceChangeEvent.PRE_DELETE
IResourceChangeEvent.PRE_CLOSE

This list may increase in the future.
Params:
listener – the listener
eventMask – the bit-wise OR of all event types of interest to the
listener
See Also:
removePreProcessingResourceChangedListener(IResourceChangeListener)
IResourceChangeEvent
Since:
3.2/**
	 * Adds the given listener for resource change events of the given types to the Java core.
	 * The listener is guaranteed to be notified of the resource change event before
	 * the Java core starts processing the resource change event itself.
	 * <p>
	 * If an identical listener is already registered, the given event types are added to the event types
	 * of interest to the listener.
	 * </p>
	 * <p>
	 * Supported event types are:
	 * </p>
	 * <ul>
	 * <li>{@link IResourceChangeEvent#PRE_BUILD}</li>
	 * <li>{@link IResourceChangeEvent#POST_BUILD}</li>
	 * <li>{@link IResourceChangeEvent#POST_CHANGE}</li>
	 * <li>{@link IResourceChangeEvent#PRE_DELETE}</li>
	 * <li>{@link IResourceChangeEvent#PRE_CLOSE}</li>
	 * </ul>
	 * This list may increase in the future.
	 *
	 * @param listener the listener
	 * @param eventMask the bit-wise OR of all event types of interest to the
	 * listener
	 * @see #removePreProcessingResourceChangedListener(IResourceChangeListener)
	 * @see IResourceChangeEvent
	 * @since 3.2
	 */
	public static void addPreProcessingResourceChangedListener(IResourceChangeListener listener, int eventMask) {
		JavaModelManager.getDeltaState().addPreResourceChangedListener(listener, eventMask);
	}

	
Configures the given marker for the given Java element.
Used for markers, which denote a Java element rather than a resource.
Params:
marker – the marker to be configured
element – the Java element for which the marker needs to be configured
Throws:
CoreException – if the IMarker.setAttribute on the marker fails/**
	 * Configures the given marker for the given Java element.
	 * Used for markers, which denote a Java element rather than a resource.
	 *
	 * @param marker the marker to be configured
	 * @param element the Java element for which the marker needs to be configured
	 * @exception CoreException if the <code>IMarker.setAttribute</code> on the marker fails
	 */
	public void configureJavaElementMarker(IMarker marker, IJavaElement element)
		throws CoreException {
		if (element instanceof IMember)
			element = ((IMember) element).getClassFile();
		if (marker != null && element != null)
			marker.setAttribute(ATT_HANDLE_ID, element.getHandleIdentifier());
	}

	
Returns the Java model element corresponding to the given handle identifier
generated by IJavaElement.getHandleIdentifier(), or
null if unable to create the associated element.
Params:
handleIdentifier – the given handle identifier
Returns:
the Java element corresponding to the handle identifier/**
	 * Returns the Java model element corresponding to the given handle identifier
	 * generated by <code>IJavaElement.getHandleIdentifier()</code>, or
	 * <code>null</code> if unable to create the associated element.
	 *
	 * @param handleIdentifier the given handle identifier
	 * @return the Java element corresponding to the handle identifier
	 */
	public static IJavaElement create(String handleIdentifier) {
		return create(handleIdentifier, DefaultWorkingCopyOwner.PRIMARY);
	}

	
Returns the Java model element corresponding to the given handle identifier
generated by IJavaElement.getHandleIdentifier(), or
null if unable to create the associated element.
If the returned Java element is an ICompilationUnit or an element
inside a compilation unit, the compilation unit's owner is the given owner if such a
working copy exists, otherwise the compilation unit is a primary compilation unit.
Params:
handleIdentifier – the given handle identifier
owner – the owner of the returned compilation unit, ignored if the returned
  element is not a compilation unit, or an element inside a compilation unit
Returns:
the Java element corresponding to the handle identifier
Since:
3.0/**
	 * Returns the Java model element corresponding to the given handle identifier
	 * generated by <code>IJavaElement.getHandleIdentifier()</code>, or
	 * <code>null</code> if unable to create the associated element.
	 * If the returned Java element is an <code>ICompilationUnit</code> or an element
	 * inside a compilation unit, the compilation unit's owner is the given owner if such a
	 * working copy exists, otherwise the compilation unit is a primary compilation unit.
	 *
	 * @param handleIdentifier the given handle identifier
	 * @param owner the owner of the returned compilation unit, ignored if the returned
	 *   element is not a compilation unit, or an element inside a compilation unit
	 * @return the Java element corresponding to the handle identifier
	 * @since 3.0
	 */
	public static IJavaElement create(String handleIdentifier, WorkingCopyOwner owner) {
		if (handleIdentifier == null) {
			return null;
		}
		if (owner == null)
			owner = DefaultWorkingCopyOwner.PRIMARY;
		MementoTokenizer memento = new MementoTokenizer(handleIdentifier);
		JavaModel model = JavaModelManager.getJavaModelManager().getJavaModel();
		return model.getHandleFromMemento(memento, owner);
	}

	
Returns the Java element corresponding to the given file, or
null if unable to associate the given file
with a Java element.
The file must be one of:

a file with one of the 
     Java-like extensions - the element returned is the corresponding ICompilationUnit
a .class file - the element returned is the corresponding IClassFile
a ZIP archive (e.g. a .jar, a .zip file, etc.) - the element returned is the corresponding IPackageFragmentRoot


Creating a Java element has the side effect of creating and opening all of the
element's parents if they are not yet open.

Params:
file – the given file
Returns:
the Java element corresponding to the given file, or
null if unable to associate the given file
with a Java element/**
	 * Returns the Java element corresponding to the given file, or
	 * <code>null</code> if unable to associate the given file
	 * with a Java element.
	 *
	 * <p>The file must be one of:</p>
	 *	<ul>
	 *	<li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
	 *      Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
	 *	<li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
	 *	<li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
	 *	</ul>
	 * <p>
	 * Creating a Java element has the side effect of creating and opening all of the
	 * element's parents if they are not yet open.
	 * </p>
	 *
	 * @param file the given file
	 * @return the Java element corresponding to the given file, or
	 * <code>null</code> if unable to associate the given file
	 * with a Java element
	 */
	public static IJavaElement create(IFile file) {
		return JavaModelManager.create(file, null/*unknown java project*/);
	}
	
Returns the package fragment or package fragment root corresponding to the given folder, or
null if unable to associate the given folder with a Java element.

Note that a package fragment root is returned rather than a default package.


Creating a Java element has the side effect of creating and opening all of the
element's parents if they are not yet open.

Params:
folder – the given folder
Returns:
the package fragment or package fragment root corresponding to the given folder, or
null if unable to associate the given folder with a Java element/**
	 * Returns the package fragment or package fragment root corresponding to the given folder, or
	 * <code>null</code> if unable to associate the given folder with a Java element.
	 * <p>
	 * Note that a package fragment root is returned rather than a default package.
	 * </p>
	 * <p>
	 * Creating a Java element has the side effect of creating and opening all of the
	 * element's parents if they are not yet open.
	 * </p>
	 *
	 * @param folder the given folder
	 * @return the package fragment or package fragment root corresponding to the given folder, or
	 * <code>null</code> if unable to associate the given folder with a Java element
	 */
	public static IJavaElement create(IFolder folder) {
		return JavaModelManager.create(folder, null/*unknown java project*/);
	}
	
Returns the Java project corresponding to the given project.

Creating a Java Project has the side effect of creating and opening all of the
project's parents if they are not yet open.


Note that no check is done at this time on the existence or the java nature of this project.

Params:
project – the given project
Returns:
the Java project corresponding to the given project, null if the given project is null/**
	 * Returns the Java project corresponding to the given project.
	 * <p>
	 * Creating a Java Project has the side effect of creating and opening all of the
	 * project's parents if they are not yet open.
	 * </p>
	 * <p>
	 * Note that no check is done at this time on the existence or the java nature of this project.
	 * </p>
	 *
	 * @param project the given project
	 * @return the Java project corresponding to the given project, null if the given project is null
	 */
	public static IJavaProject create(IProject project) {
		if (project == null) {
			return null;
		}
		JavaModel javaModel = JavaModelManager.getJavaModelManager().getJavaModel();
		return javaModel.getJavaProject(project);
	}
	
Returns the Java element corresponding to the given resource, or
null if unable to associate the given resource
with a Java element.

The resource must be one of:


a project - the element returned is the corresponding IJavaProject
a file with one of the 
     Java-like extensions - the element returned is the corresponding ICompilationUnit
a .class file - the element returned is the corresponding IClassFile
a ZIP archive (e.g. a .jar, a .zip file, etc.) - the element returned is the corresponding IPackageFragmentRoot
 
a folder - the element returned is the corresponding IPackageFragmentRoot
   	or IPackageFragment
 
the workspace root resource - the element returned is the IJavaModel


Creating a Java element has the side effect of creating and opening all of the
element's parents if they are not yet open.

Params:
resource – the given resource
Returns:
the Java element corresponding to the given resource, or
null if unable to associate the given resource
with a Java element/**
	 * Returns the Java element corresponding to the given resource, or
	 * <code>null</code> if unable to associate the given resource
	 * with a Java element.
	 * <p>
	 * The resource must be one of:
	 * </p>
	 *	<ul>
	 *	<li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
	 *	<li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
	 *      Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
	 *	<li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
	 *	<li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
	 *  <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
	 *    	or <code>IPackageFragment</code></li>
	 *  <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
	 *	</ul>
	 * <p>
	 * Creating a Java element has the side effect of creating and opening all of the
	 * element's parents if they are not yet open.
	 * </p>
	 *
	 * @param resource the given resource
	 * @return the Java element corresponding to the given resource, or
	 * <code>null</code> if unable to associate the given resource
	 * with a Java element
	 */
	public static IJavaElement create(IResource resource) {
		return JavaModelManager.create(resource, null/*unknown java project*/);
	}
	
Returns the Java element corresponding to the given file, its project being the given
project. Returns null if unable to associate the given resource
with a Java element.

The resource must be one of:


a project - the element returned is the corresponding IJavaProject
a file with one of the 
     Java-like extensions - the element returned is the corresponding ICompilationUnit
a .class file - the element returned is the corresponding IClassFile
a ZIP archive (e.g. a .jar, a .zip file, etc.) - the element returned is the corresponding IPackageFragmentRoot
 
a folder - the element returned is the corresponding IPackageFragmentRoot
   	or IPackageFragment
 
the workspace root resource - the element returned is the IJavaModel


Creating a Java element has the side effect of creating and opening all of the
element's parents if they are not yet open.

Params:
resource – the given resource
Returns:
the Java element corresponding to the given file, or
null if unable to associate the given file
with a Java element
Since:
3.3/**
	 * Returns the Java element corresponding to the given file, its project being the given
	 * project. Returns <code>null</code> if unable to associate the given resource
	 * with a Java element.
	 * <p>
	 * The resource must be one of:
	 * </p>
	 *	<ul>
	 *	<li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
	 *	<li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
	 *      Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
	 *	<li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
	 *	<li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
	 *  <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
	 *    	or <code>IPackageFragment</code></li>
	 *  <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
	 *	</ul>
	 * <p>
	 * Creating a Java element has the side effect of creating and opening all of the
	 * element's parents if they are not yet open.
	 * </p>
	 *
	 * @param resource the given resource
	 * @return the Java element corresponding to the given file, or
	 * <code>null</code> if unable to associate the given file
	 * with a Java element
	 * @since 3.3
	 */
	public static IJavaElement create(IResource resource, IJavaProject project) {
		return JavaModelManager.create(resource, project);
	}
	
Returns the Java model.
Params:
root – the given root
Returns:
the Java model, or null if the root is null/**
	 * Returns the Java model.
	 *
	 * @param root the given root
	 * @return the Java model, or <code>null</code> if the root is null
	 */
	public static IJavaModel create(IWorkspaceRoot root) {
		if (root == null) {
			return null;
		}
		return JavaModelManager.getJavaModelManager().getJavaModel();
	}
	
Creates and returns a class file element for
the given .class file. Returns null if unable
to recognize the class file.
Params:
file – the given .class file
Returns:
a class file element for the given .class file, or null if unable
to recognize the class file/**
	 * Creates and returns a class file element for
	 * the given <code>.class</code> file. Returns <code>null</code> if unable
	 * to recognize the class file.
	 *
	 * @param file the given <code>.class</code> file
	 * @return a class file element for the given <code>.class</code> file, or <code>null</code> if unable
	 * to recognize the class file
	 */
	public static IClassFile createClassFileFrom(IFile file) {
		return JavaModelManager.createClassFileFrom(file, null);
	}
	
Creates and returns a compilation unit element for the given source file (i.e. a file with one of the 
Java-like extensions). Returns null if unable
to recognize the compilation unit.
Params:
file – the given source file
Returns:
a compilation unit element for the given source file, or null if unable
to recognize the compilation unit/**
	 * Creates and returns a compilation unit element for
	 * the given source file (i.e. a file with one of the {@link JavaCore#getJavaLikeExtensions()
	 * Java-like extensions}). Returns <code>null</code> if unable
	 * to recognize the compilation unit.
	 *
	 * @param file the given source file
	 * @return a compilation unit element for the given source file, or <code>null</code> if unable
	 * to recognize the compilation unit
	 */
	public static ICompilationUnit createCompilationUnitFrom(IFile file) {
		return JavaModelManager.createCompilationUnitFrom(file, null/*unknown java project*/);
	}
	
Creates and returns a handle for the given JAR file.
The Java model associated with the JAR's project may be
created as a side effect.
Params:
file – the given JAR file
Returns:
a handle for the given JAR file, or null if unable to create a JAR package fragment root.
(for example, if the JAR file represents a non-Java resource)/**
	 * Creates and returns a handle for the given JAR file.
	 * The Java model associated with the JAR's project may be
	 * created as a side effect.
	 *
	 * @param file the given JAR file
	 * @return a handle for the given JAR file, or <code>null</code> if unable to create a JAR package fragment root.
	 * (for example, if the JAR file represents a non-Java resource)
	 */
	public static IPackageFragmentRoot createJarPackageFragmentRootFrom(IFile file) {
		return JavaModelManager.createJarPackageFragmentRootFrom(file, null/*unknown java project*/);
	}

	
Answers the project specific value for a given classpath container.
In case this container path could not be resolved, then will answer null.
Both the container path and the project context are supposed to be non-null.

The containerPath is a formed by a first ID segment followed with extra segments, which can be
used as additional hints for resolution. If no container was ever recorded for this container path
onto this project (using setClasspathContainer, then a
ClasspathContainerInitializer will be activated if any was registered for this container
ID onto the extension point "org.eclipse.jdt.core.classpathContainerInitializer".


There is no assumption that the returned container must answer the exact same containerPath
when requested IClasspathContainer#getPath.
Indeed, the containerPath is just an indication for resolving it to an actual container object.


Classpath container values are persisted locally to the workspace, but
are not preserved from a session to another. It is thus highly recommended to register a
ClasspathContainerInitializer for each referenced container
(through the extension point "org.eclipse.jdt.core.ClasspathContainerInitializer").

Params:
containerPath – the name of the container, which needs to be resolved
project – a specific project in which the container is being resolved
Throws:
JavaModelException – if an exception occurred while resolving the container, or if the resolved container
  contains illegal entries (contains CPE_CONTAINER entries or null entries).
See Also:
ClasspathContainerInitializer
IClasspathContainer
setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
Returns:
the corresponding classpath container or null if unable to find one.
Since:
2.0/**
	 * Answers the project specific value for a given classpath container.
	 * In case this container path could not be resolved, then will answer <code>null</code>.
	 * Both the container path and the project context are supposed to be non-null.
	 * <p>
	 * The containerPath is a formed by a first ID segment followed with extra segments, which can be
	 * used as additional hints for resolution. If no container was ever recorded for this container path
	 * onto this project (using <code>setClasspathContainer</code>, then a
	 * <code>ClasspathContainerInitializer</code> will be activated if any was registered for this container
	 * ID onto the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
	 * </p>
	 * <p>
	 * There is no assumption that the returned container must answer the exact same containerPath
	 * when requested <code>IClasspathContainer#getPath</code>.
	 * Indeed, the containerPath is just an indication for resolving it to an actual container object.
	 * </p>
	 * <p>
	 * Classpath container values are persisted locally to the workspace, but
	 * are not preserved from a session to another. It is thus highly recommended to register a
	 * <code>ClasspathContainerInitializer</code> for each referenced container
	 * (through the extension point "org.eclipse.jdt.core.ClasspathContainerInitializer").
	 * </p>
	 *
	 * @param containerPath the name of the container, which needs to be resolved
	 * @param project a specific project in which the container is being resolved
	 * @return the corresponding classpath container or <code>null</code> if unable to find one.
	 *
	 * @exception JavaModelException if an exception occurred while resolving the container, or if the resolved container
	 *   contains illegal entries (contains CPE_CONTAINER entries or null entries).
	 *
	 * @see ClasspathContainerInitializer
	 * @see IClasspathContainer
	 * @see #setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
	 * @since 2.0
	 */
	public static IClasspathContainer getClasspathContainer(IPath containerPath, IJavaProject project) throws JavaModelException {

	    JavaModelManager manager = JavaModelManager.getJavaModelManager();
		IClasspathContainer container = manager.getClasspathContainer(containerPath, project);
		if (container == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) {
		    return manager.getPreviousSessionContainer(containerPath, project);
		}
		return container;
	}

	
Helper method finding the classpath container initializer registered for a given classpath container ID
or null if none was found while iterating over the contributions to extension point to
the extension point "org.eclipse.jdt.core.classpathContainerInitializer".

A containerID is the first segment of any container path, used to identify the registered container initializer.

Params:
containerID – - a containerID identifying a registered initializer
Returns:
ClasspathContainerInitializer - the registered classpath container initializer or null if
none was found.
Since:
2.1/**
	 * Helper method finding the classpath container initializer registered for a given classpath container ID
	 * or <code>null</code> if none was found while iterating over the contributions to extension point to
	 * the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
	 * <p>
	 * A containerID is the first segment of any container path, used to identify the registered container initializer.
	 * </p>
	 * @param containerID - a containerID identifying a registered initializer
	 * @return ClasspathContainerInitializer - the registered classpath container initializer or <code>null</code> if
	 * none was found.
	 * @since 2.1
	 */
	public static ClasspathContainerInitializer getClasspathContainerInitializer(String containerID) {
		Hashtable containerInitializersCache = JavaModelManager.getJavaModelManager().containerInitializersCache;
		ClasspathContainerInitializer initializer = (ClasspathContainerInitializer) containerInitializersCache.get(containerID);
		if (initializer == null) {
			initializer = computeClasspathContainerInitializer(containerID);
			if (initializer == null)
				return null;
			containerInitializersCache.put(containerID, initializer);
		}
		return initializer;
	}

	private static ClasspathContainerInitializer computeClasspathContainerInitializer(String containerID) {
		Plugin jdtCorePlugin = JavaCore.getPlugin();
		if (jdtCorePlugin == null) return null;

		IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(JavaCore.PLUGIN_ID, JavaModelManager.CPCONTAINER_INITIALIZER_EXTPOINT_ID);
		if (extension != null) {
			IExtension[] extensions =  extension.getExtensions();
			for(int i = 0; i < extensions.length; i++){
				IConfigurationElement [] configElements = extensions[i].getConfigurationElements();
				for(int j = 0; j < configElements.length; j++){
					IConfigurationElement configurationElement = configElements[j];
					String initializerID = configurationElement.getAttribute("id"); //$NON-NLS-1$
					if (initializerID != null && initializerID.equals(containerID)){
						if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
							verbose_found_container_initializer(containerID, configurationElement);
						try {
							Object execExt = configurationElement.createExecutableExtension("class"); //$NON-NLS-1$
							if (execExt instanceof ClasspathContainerInitializer){
								return (ClasspathContainerInitializer)execExt;
							}
						} catch(CoreException e) {
							// executable extension could not be created: ignore this initializer
							if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE) {
								verbose_failed_to_instanciate_container_initializer(containerID, configurationElement);
								e.printStackTrace();
							}
						}
					}
				}
			}
		}
		return null;
	}

	private static void verbose_failed_to_instanciate_container_initializer(String containerID, IConfigurationElement configurationElement) {
		Util.verbose(
			"CPContainer INIT - failed to instanciate initializer\n" + //$NON-NLS-1$
			"	container ID: " + containerID + '\n' + //$NON-NLS-1$
			"	class: " + configurationElement.getAttribute("class"), //$NON-NLS-1$ //$NON-NLS-2$
			System.err);
	}

	private static void verbose_found_container_initializer(String containerID, IConfigurationElement configurationElement) {
		Util.verbose(
			"CPContainer INIT - found initializer\n" + //$NON-NLS-1$
			"	container ID: " + containerID + '\n' + //$NON-NLS-1$
			"	class: " + configurationElement.getAttribute("class")); //$NON-NLS-1$ //$NON-NLS-2$
	}

	
Returns the path held in the given classpath variable.
Returns null if unable to bind.

Classpath variable values are persisted locally to the workspace, and
are preserved from session to session.


Note that classpath variables can be contributed registered initializers for,
using the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
If an initializer is registered for a variable, its persisted value will be ignored:
its initializer will thus get the opportunity to rebind the variable differently on
each session.

Params:
variableName – the name of the classpath variable
See Also:
setClasspathVariable(String, IPath)
Returns:
the path, or null if none/**
	 * Returns the path held in the given classpath variable.
	 * Returns <code>null</code> if unable to bind.
	 * <p>
	 * Classpath variable values are persisted locally to the workspace, and
	 * are preserved from session to session.
	 * </p>
	 * <p>
	 * Note that classpath variables can be contributed registered initializers for,
	 * using the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
	 * If an initializer is registered for a variable, its persisted value will be ignored:
	 * its initializer will thus get the opportunity to rebind the variable differently on
	 * each session.
	 * </p>
	 *
	 * @param variableName the name of the classpath variable
	 * @return the path, or <code>null</code> if none
	 * @see #setClasspathVariable(String, IPath)
	 */
	public static IPath getClasspathVariable(final String variableName) {

	    JavaModelManager manager = JavaModelManager.getJavaModelManager();
		IPath variablePath = manager.variableGet(variableName);
		if (variablePath == JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS){
		    return manager.getPreviousSessionVariable(variableName);
		}

		if (variablePath != null) {
			if (variablePath == JavaModelManager.CP_ENTRY_IGNORE_PATH)
				return null;
			return variablePath;
		}

		// even if persisted value exists, initializer is given priority, only if no initializer is found the persisted value is reused
		final ClasspathVariableInitializer initializer = JavaCore.getClasspathVariableInitializer(variableName);
		if (initializer != null){
			if (JavaModelManager.CP_RESOLVE_VERBOSE)
				verbose_triggering_variable_initialization(variableName, initializer);
			if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
				verbose_triggering_variable_initialization_invocation_trace();
			manager.variablePut(variableName, JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS); // avoid initialization cycles
			boolean ok = false;
			try {
				// let OperationCanceledException go through
				// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59363)
				initializer.initialize(variableName);

				variablePath = manager.variableGet(variableName); // initializer should have performed side-effect
				if (variablePath == JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS) return null; // break cycle (initializer did not init or reentering call)
				if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
					verbose_variable_value_after_initialization(variableName, variablePath);
				manager.variablesWithInitializer.add(variableName);
				ok = true;
			} catch (RuntimeException | Error e) {
				if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE)
					e.printStackTrace();
				throw e;
			} finally {
				if (!ok) JavaModelManager.getJavaModelManager().variablePut(variableName, null); // flush cache
			}
		} else {
			if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE)
				verbose_no_variable_initializer_found(variableName);
		}
		return variablePath;
	}

	private static void verbose_no_variable_initializer_found(String variableName) {
		Util.verbose(
			"CPVariable INIT - no initializer found\n" + //$NON-NLS-1$
			"	variable: " + variableName); //$NON-NLS-1$
	}

	private static void verbose_variable_value_after_initialization(String variableName, IPath variablePath) {
		Util.verbose(
			"CPVariable INIT - after initialization\n" + //$NON-NLS-1$
			"	variable: " + variableName +'\n' + //$NON-NLS-1$
			"	variable path: " + variablePath); //$NON-NLS-1$
	}

	private static void verbose_triggering_variable_initialization(String variableName, ClasspathVariableInitializer initializer) {
		Util.verbose(
			"CPVariable INIT - triggering initialization\n" + //$NON-NLS-1$
			"	variable: " + variableName + '\n' + //$NON-NLS-1$
			"	initializer: " + initializer); //$NON-NLS-1$
	}

	private static void verbose_triggering_variable_initialization_invocation_trace() {
		Util.verbose(
			"CPVariable INIT - triggering initialization\n" + //$NON-NLS-1$
			"	invocation trace:"); //$NON-NLS-1$
		new Exception("<Fake exception>").printStackTrace(System.out); //$NON-NLS-1$
	}

	
Returns deprecation message of a given classpath variable.
Params:
variableName – 
Returns:
A string if the classpath variable is deprecated, null otherwise.
Since:
3.3/**
	 * Returns deprecation message of a given classpath variable.
	 *
	 * @param variableName
	 * @return A string if the classpath variable is deprecated, <code>null</code> otherwise.
	 * @since 3.3
	 */
	public static String getClasspathVariableDeprecationMessage(String variableName) {
	    JavaModelManager manager = JavaModelManager.getJavaModelManager();

		// Returns the stored deprecation message
		String message = manager.deprecatedVariables.get(variableName);
		if (message != null) {
		    return message;
		}

	    // If the variable has been already initialized, then there's no deprecation message
		IPath variablePath = manager.variableGet(variableName);
		if (variablePath != null && variablePath != JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS) {
			return null;
		}

		// Search for extension point to get the possible deprecation message
		Plugin jdtCorePlugin = JavaCore.getPlugin();
		if (jdtCorePlugin == null) return null;

		IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(JavaCore.PLUGIN_ID, JavaModelManager.CPVARIABLE_INITIALIZER_EXTPOINT_ID);
		if (extension != null) {
			IExtension[] extensions =  extension.getExtensions();
			for(int i = 0; i < extensions.length; i++){
				IConfigurationElement [] configElements = extensions[i].getConfigurationElements();
				for(int j = 0; j < configElements.length; j++){
					IConfigurationElement configElement = configElements[j];
					String varAttribute = configElement.getAttribute("variable"); //$NON-NLS-1$
					if (variableName.equals(varAttribute)) {
						String deprecatedAttribute = configElement.getAttribute("deprecated"); //$NON-NLS-1$
						if (deprecatedAttribute != null) {
							return deprecatedAttribute;
						}
					}
				}
			}
		}
		return null;
	}

	
Helper method finding the classpath variable initializer registered for a given classpath variable name
or null if none was found while iterating over the contributions to extension point to
the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
Params:
variable – the given variable
Returns:
ClasspathVariableInitializer - the registered classpath variable initializer or null if
none was found.
Since:
2.1/**
	 * Helper method finding the classpath variable initializer registered for a given classpath variable name
	 * or <code>null</code> if none was found while iterating over the contributions to extension point to
	 * the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
	 *
 	 * @param variable the given variable
 	 * @return ClasspathVariableInitializer - the registered classpath variable initializer or <code>null</code> if
	 * none was found.
	 * @since 2.1
 	 */
	public static ClasspathVariableInitializer getClasspathVariableInitializer(String variable){

		Plugin jdtCorePlugin = JavaCore.getPlugin();
		if (jdtCorePlugin == null) return null;

		IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(JavaCore.PLUGIN_ID, JavaModelManager.CPVARIABLE_INITIALIZER_EXTPOINT_ID);
		if (extension != null) {
			IExtension[] extensions =  extension.getExtensions();
			for(int i = 0; i < extensions.length; i++){
				IConfigurationElement [] configElements = extensions[i].getConfigurationElements();
				for(int j = 0; j < configElements.length; j++){
					IConfigurationElement configElement = configElements[j];
					try {
						String varAttribute = configElement.getAttribute("variable"); //$NON-NLS-1$
						if (variable.equals(varAttribute)) {
							if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
								verbose_found_variable_initializer(variable, configElement);
							Object execExt = configElement.createExecutableExtension("class"); //$NON-NLS-1$
							if (execExt instanceof ClasspathVariableInitializer){
								ClasspathVariableInitializer initializer = (ClasspathVariableInitializer)execExt;
								String deprecatedAttribute = configElement.getAttribute("deprecated"); //$NON-NLS-1$
								if (deprecatedAttribute != null) {
									JavaModelManager.getJavaModelManager().deprecatedVariables.put(variable, deprecatedAttribute);
								}
								String readOnlyAttribute = configElement.getAttribute("readOnly"); //$NON-NLS-1$
								if (JavaModelManager.TRUE.equals(readOnlyAttribute)) {
									JavaModelManager.getJavaModelManager().readOnlyVariables.add(variable);
								}
								return initializer;
							}
						}
					} catch(CoreException e){
						// executable extension could not be created: ignore this initializer
						if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE) {
							verbose_failed_to_instanciate_variable_initializer(variable, configElement);
							e.printStackTrace();
						}
					}
				}
			}
		}
		return null;
	}

	private static void verbose_failed_to_instanciate_variable_initializer(String variable, IConfigurationElement configElement) {
		Util.verbose(
			"CPContainer INIT - failed to instanciate initializer\n" + //$NON-NLS-1$
			"	variable: " + variable + '\n' + //$NON-NLS-1$
			"	class: " + configElement.getAttribute("class"), //$NON-NLS-1$ //$NON-NLS-2$
			System.err);
	}

	private static void verbose_found_variable_initializer(String variable, IConfigurationElement configElement) {
		Util.verbose(
			"CPVariable INIT - found initializer\n" + //$NON-NLS-1$
			"	variable: " + variable + '\n' + //$NON-NLS-1$
			"	class: " + configElement.getAttribute("class")); //$NON-NLS-1$ //$NON-NLS-2$
	}

	
Returns the names of all known classpath variables.

Classpath variable values are persisted locally to the workspace, and
are preserved from session to session.

See Also:
setClasspathVariable(String, IPath)
Returns:
the list of classpath variable names/**
	 * Returns the names of all known classpath variables.
	 * <p>
	 * Classpath variable values are persisted locally to the workspace, and
	 * are preserved from session to session.
	 * </p>
	 *
	 * @return the list of classpath variable names
	 * @see #setClasspathVariable(String, IPath)
	 */
	public static String[] getClasspathVariableNames() {
		return JavaModelManager.getJavaModelManager().variableNames();
	}

	
Returns a table of all known configurable options with their default values.
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 setOptions.

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 table of all known configurable options with their default values/**
	 * Returns a table of all known configurable options with their default values.
	 * 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>.
	 * <p>
	 * 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.
	 * </p>
	 * <p>
	 * Note: each release may add new options.
	 * </p>
	 *
	 * @return a table of all known configurable options with their default values
	 */
	public static Hashtable<String, String> getDefaultOptions(){
		return JavaModelManager.getJavaModelManager().getDefaultOptions();
	}

	
Returns the workspace root default charset encoding.
See Also:
IContainer.getDefaultCharset()
ResourcesPlugin.getEncoding()
Returns:
the name of the default charset encoding for workspace root.
Since:
3.0/**
	 * Returns the workspace root default charset encoding.
	 *
	 * @return the name of the default charset encoding for workspace root.
	 * @see IContainer#getDefaultCharset()
	 * @see ResourcesPlugin#getEncoding()
	 * @since 3.0
	 */
	public static String getEncoding() {
		try {
			return ResourcesPlugin.getWorkspace().getRoot().getDefaultCharset();
		}
		catch (IllegalStateException ise) {
			// happen when there's no workspace (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=216817)
			// or when it is shutting down (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=60687)
			return System.getProperty("file.encoding"); //$NON-NLS-1$
		}
		catch (CoreException ce) {
			// fails silently and return plugin global encoding if core exception occurs
		}
		return ResourcesPlugin.getEncoding();
	}

	
Returns an array that contains the resources generated by the Java builder when building the
compilation units contained in the given region.
The contents of the array is accurate only if the elements of the given region have been built.
The given region can contain instances of:

org.eclipse.jdt.core.ICompilationUnit
org.eclipse.jdt.core.IPackageFragment
org.eclipse.jdt.core.IPackageFragmentRoot
org.eclipse.jdt.core.IJavaProject

All other types of org.eclipse.jdt.core.IJavaElement are ignored.
Params:
region – the given region
includesNonJavaResources – a flag that indicates if non-java resources should be included
Throws:
IllegalArgumentException – if the given region is null
Returns:
an array that contains the resources generated by the Java builder when building the
compilation units contained in the given region, an empty array if none
Since:
3.3/**
	 * Returns an array that contains the resources generated by the Java builder when building the
	 * compilation units contained in the given region.
	 * <p>The contents of the array is accurate only if the elements of the given region have been built.</p>
	 * <p>The given region can contain instances of:</p>
	 * <ul>
	 * <li><code>org.eclipse.jdt.core.ICompilationUnit</code></li>
	 * <li><code>org.eclipse.jdt.core.IPackageFragment</code></li>
	 * <li><code>org.eclipse.jdt.core.IPackageFragmentRoot</code></li>
	 * <li><code>org.eclipse.jdt.core.IJavaProject</code></li>
	 * </ul>
	 * <p>All other types of <code>org.eclipse.jdt.core.IJavaElement</code> are ignored.</p>
	 *
	 * @param region the given region
	 * @param includesNonJavaResources a flag that indicates if non-java resources should be included
	 *
	 * @return an array that contains the resources generated by the Java builder when building the
	 * compilation units contained in the given region, an empty array if none
	 * @exception IllegalArgumentException if the given region is <code>null</code>
	 * @since 3.3
	 */
	public static IResource[] getGeneratedResources(IRegion region, boolean includesNonJavaResources) {
		if (region == null) throw new IllegalArgumentException("region cannot be null"); //$NON-NLS-1$
		IJavaElement[] elements = region.getElements();
		HashMap projectsStates = new HashMap();
		ArrayList collector = new ArrayList();
		for (int i = 0, max = elements.length; i < max; i++) {
			// collect all the java project
			IJavaElement element = elements[i];
			IJavaProject javaProject = element.getJavaProject();
			IProject project = javaProject.getProject();
			State state = null;
			State currentState = (State) projectsStates.get(project);
			if (currentState != null) {
				state = currentState;
			} else {
				state = (State) JavaModelManager.getJavaModelManager().getLastBuiltState(project, null);
				if (state != null) {
					projectsStates.put(project, state);
				}
			}
			if (state == null) continue;
			if (element.getElementType() == IJavaElement.JAVA_PROJECT) {
				IPackageFragmentRoot[] roots = null;
				try {
					roots = javaProject.getPackageFragmentRoots();
				} catch (JavaModelException e) {
					// ignore
				}
				if (roots == null) continue;
				IRegion region2 = JavaCore.newRegion();
				for (int j = 0; j < roots.length; j++) {
					region2.add(roots[j]);
				}
				IResource[] res = getGeneratedResources(region2, includesNonJavaResources);
				for (int j = 0, max2 = res.length; j < max2; j++) {
					collector.add(res[j]);
				}
				continue;
			}
			IPath outputLocation = null;
			try {
				outputLocation = javaProject.getOutputLocation();
			} catch (JavaModelException e) {
				// ignore
			}
			IJavaElement root = element;
			while (root != null && root.getElementType() != IJavaElement.PACKAGE_FRAGMENT_ROOT) {
				root = root.getParent();
			}
			if (root == null) continue;
			IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) root;
			int rootPathSegmentCounts = packageFragmentRoot.getPath().segmentCount();
			try {
				IClasspathEntry entry = packageFragmentRoot.getRawClasspathEntry();
				IPath entryOutputLocation = entry.getOutputLocation();
				if (entryOutputLocation != null) {
					outputLocation = entryOutputLocation;
				}
			} catch (JavaModelException e) {
				e.printStackTrace();
			}
			if (outputLocation == null) continue;
			IContainer container = (IContainer) project.getWorkspace().getRoot().findMember(outputLocation);
			switch(element.getElementType()) {
				case IJavaElement.COMPILATION_UNIT :
					// get the .class files generated when this element was built
					ICompilationUnit unit = (ICompilationUnit) element;
					getGeneratedResource(unit, container, state, rootPathSegmentCounts, collector);
					break;
				case IJavaElement.PACKAGE_FRAGMENT :
					// collect all the .class files generated when all the units in this package were built
					IPackageFragment fragment = (IPackageFragment) element;
					ICompilationUnit[] compilationUnits = null;
					try {
						compilationUnits = fragment.getCompilationUnits();
					} catch (JavaModelException e) {
						// ignore
					}
					if (compilationUnits == null) continue;
					for (int j = 0, max2 = compilationUnits.length; j < max2; j++) {
						getGeneratedResource(compilationUnits[j], container, state, rootPathSegmentCounts, collector);
					}
					if (includesNonJavaResources) {
						// retrieve all non-java resources from the output location using the package fragment path
						Object[] nonJavaResources = null;
						try {
							nonJavaResources = fragment.getNonJavaResources();
						} catch (JavaModelException e) {
							// ignore
						}
						if (nonJavaResources != null) {
							addNonJavaResources(nonJavaResources, container, rootPathSegmentCounts, collector);
						}
					}
					break;
				case IJavaElement.PACKAGE_FRAGMENT_ROOT :
					// collect all the .class files generated when all the units in this package were built
					IPackageFragmentRoot fragmentRoot = (IPackageFragmentRoot) element;
					if (fragmentRoot.isArchive()) continue;
					IJavaElement[] children = null;
					try {
						children = fragmentRoot.getChildren();
					} catch (JavaModelException e) {
						// ignore
					}
					if (children == null) continue;
					for (int j = 0, max2 = children.length; j < max2; j++) {
						fragment = (IPackageFragment) children[j];
						ICompilationUnit[] units = null;
						try {
							units = fragment.getCompilationUnits();
						} catch (JavaModelException e) {
							// ignore
						}
						if (units == null) continue;
						for (int n = 0, max3 = units.length; n < max3; n++) {
							getGeneratedResource(units[n], container, state, rootPathSegmentCounts, collector);
						}
						if (includesNonJavaResources) {
							// retrieve all non-java resources from the output location using the package fragment path
							Object[] nonJavaResources = null;
							try {
								nonJavaResources = fragment.getNonJavaResources();
							} catch (JavaModelException e) {
								// ignore
							}
							if (nonJavaResources != null) {
								addNonJavaResources(nonJavaResources, container, rootPathSegmentCounts, collector);
							}
						}
					}
					break;
			}
		}
		int size = collector.size();
		if (size != 0) {
			IResource[] result = new IResource[size];
			collector.toArray(result);
			return result;
		}
		return NO_GENERATED_RESOURCES;
	}

	private static void getGeneratedResource(ICompilationUnit unit,
			IContainer container,
			State state,
			int rootPathSegmentCounts,
			ArrayList collector) {
		IResource resource = unit.getResource();
		char[][] typeNames = state.getDefinedTypeNamesFor(resource.getProjectRelativePath().toString());
		if (typeNames != null) {
			IPath path = unit.getPath().removeFirstSegments(rootPathSegmentCounts).removeLastSegments(1);
			for (int j = 0, max2 = typeNames.length; j < max2; j++) {
				IPath localPath = path.append(new String(typeNames[j]) + ".class"); //$NON-NLS-1$
				IResource member = container.findMember(localPath);
				if (member != null && member.exists()) {
					collector.add(member);
				}
			}
		} else {
			IPath path = unit.getPath().removeFirstSegments(rootPathSegmentCounts).removeLastSegments(1);
			path = path.append(Util.getNameWithoutJavaLikeExtension(unit.getElementName()) + ".class"); //$NON-NLS-1$
			IResource member = container.findMember(path);
			if (member != null && member.exists()) {
				collector.add(member);
			}
		}
	}

	
Returns the single instance of the Java core plug-in runtime class.
Equivalent to (JavaCore) getPlugin().
Returns:
the single instance of the Java core plug-in runtime class/**
	 * Returns the single instance of the Java core plug-in runtime class.
	 * Equivalent to <code>(JavaCore) getPlugin()</code>.
	 *
	 * @return the single instance of the Java core plug-in runtime class
	 */
	public static JavaCore getJavaCore() {
		return (JavaCore) getPlugin();
	}

	
Returns the list of known Java-like extensions. Java like extension are defined in the 
content type manager for the JAVA_SOURCE_CONTENT_TYPE. 

Note that a Java-like extension doesn't include the leading dot ('.').
Also note that the "java" extension is always defined as a Java-like extension.

Returns:
the list of known Java-like extensions.
Since:
3.2/**
	 * Returns the list of known Java-like extensions.
	 * Java like extension are defined in the {@link org.eclipse.core.runtime.Platform#getContentTypeManager()
	 * content type manager} for the {@link #JAVA_SOURCE_CONTENT_TYPE}.
	 * <p>
	 * Note that a Java-like extension doesn't include the leading dot ('.').
	 * Also note that the "java" extension is always defined as a Java-like extension.
	 * </p>
	 *
	 * @return the list of known Java-like extensions.
	 * @since 3.2
	 */
	public static String[] getJavaLikeExtensions() {
		return CharOperation.toStrings(Util.getJavaLikeExtensions());
	}

	
Helper method for returning one option value only. Equivalent to (String)JavaCore.getOptions().get(optionName)
Note that it may answer null if this option does not exist.

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.

Params:
optionName – the name of an option
See Also:
getDefaultOptions()
for changing default settings
Returns:
the String value of a given option
Since:
2.0/**
	 * 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.
	 * <p>
	 * 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.
	 * </p>
	 * <p>
	 * Note: each release may add new options.
	 * </p>
	 *
	 * @param optionName the name of an option
	 * @return the String value of a given option
	 * @see JavaCore#getDefaultOptions()
	 * @see JavaCorePreferenceInitializer for changing default settings
	 * @since 2.0
	 */
	public static String getOption(String optionName) {
		return JavaModelManager.getJavaModelManager().getOption(optionName);
	}

	
Returns the option that can be used to configure the severity of the
compiler problem identified by problemID if any,
null otherwise. Non-null return values are taken from the
constants defined by this class whose names start with
COMPILER_PB and for which the possible values of the
option are defined by { "error", "warning", "info", "ignore" }. A
null return value means that the provided problem ID is unknown or that
it matches a problem whose severity cannot be configured.
Params:
problemID – one of the problem IDs defined by IProblem
Returns:
the option that can be used to configure the severity of the
        compiler problem identified by problemID if any,
        null otherwise
Since:
3.4/**
	 * Returns the option that can be used to configure the severity of the
	 * compiler problem identified by <code>problemID</code> if any,
	 * <code>null</code> otherwise. Non-null return values are taken from the
	 * constants defined by this class whose names start with
	 * <code>COMPILER_PB</code> and for which the possible values of the
	 * option are defined by <code>{ "error", "warning", "info", "ignore" }</code>. A
	 * null return value means that the provided problem ID is unknown or that
	 * it matches a problem whose severity cannot be configured.
	 * @param problemID one of the problem IDs defined by {@link IProblem}
	 * @return the option that can be used to configure the severity of the
	 *         compiler problem identified by <code>problemID</code> if any,
	 *         <code>null</code> otherwise
	 * @since 3.4
	 */
	public static String getOptionForConfigurableSeverity(int problemID) {
		return CompilerOptions.optionKeyFromIrritant(ProblemReporter.getIrritant(problemID));
	}

	
Returns the option that can be used to configure the severity of the
compiler build path problem identified by id if any,
null otherwise. Non-null return values are taken from the
constants defined by this class whose names start with
CORE_ and for which the possible values of the
option are defined by { "error", "warning", "info", "ignore" }. A
null return value means that the provided id is unknown or that
it matches a problem whose severity cannot be configured.
Params:
id – one of the build path problems defined in IJavaModelStatusConstants
Returns:
the option that can be used to configure the severity of the
        compiler problem identified by id if any,
        null otherwise
Since:
3.16/**
	 * Returns the option that can be used to configure the severity of the
	 * compiler build path problem identified by <code>id</code> if any,
	 * <code>null</code> otherwise. Non-null return values are taken from the
	 * constants defined by this class whose names start with
	 * <code>CORE_</code> and for which the possible values of the
	 * option are defined by <code>{ "error", "warning", "info", "ignore" }</code>. A
	 * null return value means that the provided id is unknown or that
	 * it matches a problem whose severity cannot be configured.
	 * @param id one of the build path problems defined in IJavaModelStatusConstants
	 * @return the option that can be used to configure the severity of the
	 *         compiler problem identified by <code>id</code> if any,
	 *         <code>null</code> otherwise
	 * @since 3.16
	 */
	public static String getOptionForConfigurableBuildPathProblemSeverity(int id) {
		switch (id) {
			case IJavaModelStatusConstants.CLASSPATH_CYCLE:
				return JavaCore.CORE_CIRCULAR_CLASSPATH;
			case IJavaModelStatusConstants.INCOMPATIBLE_JDK_LEVEL:
				return JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL;
			case IJavaModelStatusConstants.OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE:
				return JavaCore.CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE;
			case IJavaModelStatusConstants.MAIN_ONLY_PROJECT_DEPENDS_ON_TEST_ONLY_PROJECT:
				return JavaCore.CORE_MAIN_ONLY_PROJECT_HAS_TEST_ONLY_DEPENDENCY;
			case IJavaModelStatusConstants.INVALID_CLASSPATH:
				return JavaCore.CORE_INCOMPLETE_CLASSPATH;
		}
		return null;
	}

	
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.

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.
See Also:
getDefaultOptions()
for changing default settings
Returns:
table of current settings of all options
  (key type: String; value type: String)/**
	 * 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.
	 * <p>
	 * 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.
	 * </p>
	 * <p>
	 * Note: each release may add new options.
	 * </p>
	 * <p>Returns a default set of options even if the platform is not running.</p>
	 *
	 * @return table of current settings of all options
	 *   (key type: <code>String</code>; value type: <code>String</code>)
	 * @see #getDefaultOptions()
	 * @see JavaCorePreferenceInitializer for changing default settings
	 */
	public static Hashtable<String, String> getOptions() {
		return JavaModelManager.getJavaModelManager().getOptions();
	}

	
Returns the single instance of the Java core plug-in runtime class.
Returns:
the single instance of the Java core plug-in runtime class/**
	 * Returns the single instance of the Java core plug-in runtime class.
	 *
	 * @return the single instance of the Java core plug-in runtime class
	 */
	public static Plugin getPlugin() {
		return JAVA_CORE_PLUGIN;
	}

	
This is a helper method, which returns the resolved classpath entry denoted
by a given entry (if it is a variable entry). It is obtained by resolving the variable
reference in the first segment. Returns null if unable to resolve using
the following algorithm:

 if variable segment cannot be resolved, returns null
 finds a project, JAR or binary folder in the workspace at the resolved path location
 if none finds an external JAR file or folder outside the workspace at the resolved path location 
 if none returns null


Variable source attachment path and root path are also resolved and recorded in the resulting classpath entry.


NOTE: This helper method does not handle classpath containers, for which should rather be used
JavaCore#getClasspathContainer(IPath, IJavaProject).

Params:
entry – the given variable entry
Returns:
the resolved library or project classpath entry, or null
  if the given variable entry could not be resolved to a valid classpath entry/**
	 * This is a helper method, which returns the resolved classpath entry denoted
	 * by a given entry (if it is a variable entry). It is obtained by resolving the variable
	 * reference in the first segment. Returns <code>null</code> if unable to resolve using
	 * the following algorithm:
	 * <ul>
	 * <li> if variable segment cannot be resolved, returns <code>null</code></li>
	 * <li> finds a project, JAR or binary folder in the workspace at the resolved path location</li>
	 * <li> if none finds an external JAR file or folder outside the workspace at the resolved path location </li>
	 * <li> if none returns <code>null</code></li>
	 * </ul>
	 * <p>
	 * Variable source attachment path and root path are also resolved and recorded in the resulting classpath entry.
	 * </p>
	 * <p>
	 * NOTE: This helper method does not handle classpath containers, for which should rather be used
	 * <code>JavaCore#getClasspathContainer(IPath, IJavaProject)</code>.
	 * </p>
	 *
	 * @param entry the given variable entry
	 * @return the resolved library or project classpath entry, or <code>null</code>
	 *   if the given variable entry could not be resolved to a valid classpath entry
	 */
	public static IClasspathEntry getResolvedClasspathEntry(IClasspathEntry entry) {
		return JavaModelManager.getJavaModelManager().resolveVariableEntry(entry, false/*don't use previous session value*/);
	}


	
Resolve a variable path (helper method).
Params:
variablePath – the given variable path
Returns:
the resolved variable path or null if none/**
	 * Resolve a variable path (helper method).
	 *
	 * @param variablePath the given variable path
	 * @return the resolved variable path or <code>null</code> if none
	 */
	public static IPath getResolvedVariablePath(IPath variablePath) {
		return JavaModelManager.getJavaModelManager().getResolvedVariablePath(variablePath, false/*don't use previous session value*/);
	}

	
Answers the shared working copies currently registered for this buffer factory.
Working copies can be shared by several clients using the same buffer factory,see
IWorkingCopy.getSharedWorkingCopy.
Params:
factory – the given buffer factory
Returns:
the list of shared working copies for a given buffer factory
Since:
2.0
Deprecated:
Use getWorkingCopies(WorkingCopyOwner) instead/**
	 * Answers the shared working copies currently registered for this buffer factory.
	 * Working copies can be shared by several clients using the same buffer factory,see
	 * <code>IWorkingCopy.getSharedWorkingCopy</code>.
	 *
	 * @param factory the given buffer factory
	 * @return the list of shared working copies for a given buffer factory
	 * @since 2.0
	 * @deprecated Use {@link #getWorkingCopies(WorkingCopyOwner)} instead
	 */
	public static IWorkingCopy[] getSharedWorkingCopies(IBufferFactory factory){

		// if factory is null, default factory must be used
		if (factory == null) factory = BufferManager.getDefaultBufferManager().getDefaultBufferFactory();

		return getWorkingCopies(org.eclipse.jdt.internal.core.BufferFactoryWrapper.create(factory));
	}

	
Returns the names of all defined user libraries. The corresponding classpath container path
is the name appended to the USER_LIBRARY_CONTAINER_ID.
Returns:
Return an array containing the names of all known user defined.
Since:
3.0/**
	 * Returns the names of all defined user libraries. The corresponding classpath container path
	 * is the name appended to the USER_LIBRARY_CONTAINER_ID.
	 * @return Return an array containing the names of all known user defined.
	 * @since 3.0
	 */
	public static String[] getUserLibraryNames() {
		 return JavaModelManager.getUserLibraryManager().getUserLibraryNames();
	}

	
Returns the working copies that have the given owner.
Only compilation units in working copy mode are returned.
If the owner is null, primary working copies are returned.
Params:
owner – the given working copy owner or null for primary working copy owner
Returns:
the list of working copies for a given owner
Since:
3.0/**
	 * Returns the working copies that have the given owner.
	 * Only compilation units in working copy mode are returned.
	 * If the owner is <code>null</code>, primary working copies are returned.
	 *
	 * @param owner the given working copy owner or <code>null</code> for primary working copy owner
	 * @return the list of working copies for a given owner
	 * @since 3.0
	 */
	public static ICompilationUnit[] getWorkingCopies(WorkingCopyOwner owner){

		JavaModelManager manager = JavaModelManager.getJavaModelManager();
		if (owner == null) owner = DefaultWorkingCopyOwner.PRIMARY;
		ICompilationUnit[] result = manager.getWorkingCopies(owner, false/*don't add primary WCs*/);
		if (result == null) return JavaModelManager.NO_WORKING_COPY;
		return result;
	}

	
Initializes JavaCore internal structures to allow subsequent operations (such
as the ones that need a resolved classpath) to run full speed. A client may
choose to call this method in a background thread early after the workspace
has started so that the initialization is transparent to the user.

However calling this method is optional. Services will lazily perform
initialization when invoked. This is only a way to reduce initialization
overhead on user actions, if it can be performed before at some
appropriate moment.

This initialization runs across all Java projects in the workspace. Thus the
workspace root scheduling rule is used during this operation.

This method may return before the initialization is complete. The
initialization will then continue in a background thread.

This method can be called concurrently.

Params:
monitor – a progress monitor, or null if progress
   reporting and cancellation are not desired
Throws:
CoreException – if the initialization fails,
		the status of the exception indicates the reason of the failure
Since:
3.1/**
	 * Initializes JavaCore internal structures to allow subsequent operations (such
	 * as the ones that need a resolved classpath) to run full speed. A client may
	 * choose to call this method in a background thread early after the workspace
	 * has started so that the initialization is transparent to the user.
	 * <p>
	 * However calling this method is optional. Services will lazily perform
	 * initialization when invoked. This is only a way to reduce initialization
	 * overhead on user actions, if it can be performed before at some
	 * appropriate moment.
	 * </p><p>
	 * This initialization runs across all Java projects in the workspace. Thus the
	 * workspace root scheduling rule is used during this operation.
	 * </p><p>
	 * This method may return before the initialization is complete. The
	 * initialization will then continue in a background thread.
	 * </p><p>
	 * This method can be called concurrently.
	 * </p>
	 *
	 * @param monitor a progress monitor, or <code>null</code> if progress
	 *    reporting and cancellation are not desired
	 * @exception CoreException if the initialization fails,
	 * 		the status of the exception indicates the reason of the failure
	 * @since 3.1
	 */
	public static void initializeAfterLoad(IProgressMonitor monitor) throws CoreException {
		SubMonitor mainMonitor = SubMonitor.convert(monitor, Messages.javamodel_initialization, 100);
		mainMonitor.subTask(Messages.javamodel_configuring_classpath_containers);

		// initialize all containers and variables
		JavaModelManager manager = JavaModelManager.getJavaModelManager();
		try {
			SubMonitor subMonitor = mainMonitor.split(50).setWorkRemaining(100); // 50% of the time is spent in initializing containers and variables
			subMonitor.split(5); // give feedback to the user that something is happening
			manager.batchContainerInitializationsProgress.initializeAfterLoadMonitor.set(subMonitor);
			if (manager.forceBatchInitializations(true/*initAfterLoad*/)) { // if no other thread has started the batch container initializations
				manager.getClasspathContainer(Path.EMPTY, null); // force the batch initialization
			} else { // else wait for the batch initialization to finish
				while (manager.batchContainerInitializations == JavaModelManager.BATCH_INITIALIZATION_IN_PROGRESS) {
					subMonitor.subTask(manager.batchContainerInitializationsProgress.subTaskName);
					subMonitor.split(manager.batchContainerInitializationsProgress.getWorked());
					synchronized(manager) {
						try {
							manager.wait(100);
						} catch (InterruptedException e) {
							// continue
						}
					}
				}
			}
		} finally {
			manager.batchContainerInitializationsProgress.initializeAfterLoadMonitor.set(null);
		}

		// avoid leaking source attachment properties (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=183413 )
		// and recreate links for external folders if needed
		mainMonitor.subTask(Messages.javamodel_resetting_source_attachment_properties);
		final IJavaProject[] projects = manager.getJavaModel().getJavaProjects();
		HashSet visitedPaths = new HashSet();
		ExternalFoldersManager externalFoldersManager = JavaModelManager.getExternalManager();
		for (int i = 0, length = projects.length; i < length; i++) {
			JavaProject javaProject = (JavaProject) projects[i];
			IClasspathEntry[] classpath;
			try {
				classpath = javaProject.getResolvedClasspath();
			} catch (JavaModelException e) {
				// project no longer exist: ignore
				continue;
			}
			if (classpath != null) {
				for (int j = 0, length2 = classpath.length; j < length2; j++) {
					IClasspathEntry entry = classpath[j];
					if (entry.getSourceAttachmentPath() != null) {
						IPath entryPath = entry.getPath();
						if (visitedPaths.add(entryPath)) {
							Util.setSourceAttachmentProperty(entryPath, null);
						}
					}
					// else source might have been attached by IPackageFragmentRoot#attachSource(...), we keep it
					if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
						IPath entryPath = entry.getPath();
						if (ExternalFoldersManager.isExternalFolderPath(entryPath) && externalFoldersManager.getFolder(entryPath) == null) {
							externalFoldersManager.addFolder(entryPath, true);
						}
					}
				}
			}
		}
		try {
			externalFoldersManager.createPendingFolders(mainMonitor.split(1));
		}
		catch(JavaModelException jme) {
			// Creation of external folder project failed. Log it and continue;
			Util.log(jme, "Error while processing external folders"); //$NON-NLS-1$
		}

		// ensure external jars are refreshed (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=93668)
		// before search is initialized (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=405051)
		final JavaModel model = manager.getJavaModel();
		try {
			mainMonitor.subTask(Messages.javamodel_refreshing_external_jars);
			model.refreshExternalArchives(
				null/*refresh all projects*/,
				mainMonitor.split(1) // 1% of the time is spent in jar refresh
			);
		} catch (JavaModelException e) {
			// refreshing failed: ignore
		}

		// initialize delta state
		mainMonitor.subTask(Messages.javamodel_initializing_delta_state);
		manager.deltaState.rootsAreStale = true; // in case it was already initialized before we cleaned up the source attachment properties
		manager.deltaState.initializeRoots(true/*initAfteLoad*/);

		// dummy query for waiting until the indexes are ready
		mainMonitor.subTask(Messages.javamodel_configuring_searchengine);
		// 47% of the time is spent in the dummy search
		updateLegacyIndex(mainMonitor.split(47));

		// check if the build state version number has changed since last session
		// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=98969)
		mainMonitor.subTask(Messages.javamodel_getting_build_state_number);
		QualifiedName qName = new QualifiedName(JavaCore.PLUGIN_ID, "stateVersionNumber"); //$NON-NLS-1$
		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
		String versionNumber = null;
		try {
			versionNumber = root.getPersistentProperty(qName);
		} catch (CoreException e) {
			// could not read version number: consider it is new
		}
		String newVersionNumber = Byte.toString(State.VERSION);
		if (!newVersionNumber.equals(versionNumber)) {
			// build state version number has changed: touch every projects to force a rebuild
			if (JavaBuilder.DEBUG)
				System.out.println("Build state version number has changed"); //$NON-NLS-1$
			IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
				@Override
				public void run(IProgressMonitor progressMonitor2) throws CoreException {
					for (int i = 0, length = projects.length; i < length; i++) {
						IJavaProject project = projects[i];
						try {
							if (JavaBuilder.DEBUG)
								System.out.println("Touching " + project.getElementName()); //$NON-NLS-1$
							new ClasspathValidation((JavaProject) project).validate(); // https://bugs.eclipse.org/bugs/show_bug.cgi?id=287164
							project.getProject().touch(progressMonitor2);
						} catch (CoreException e) {
							// could not touch this project: ignore
						}
					}
				}
			};
			mainMonitor.subTask(Messages.javamodel_building_after_upgrade);
			try {
				ResourcesPlugin.getWorkspace().run(runnable, mainMonitor.split(1));
			} catch (CoreException e) {
				// could not touch all projects
			}
			try {
				root.setPersistentProperty(qName, newVersionNumber);
			} catch (CoreException e) {
				Util.log(e, "Could not persist build state version number"); //$NON-NLS-1$
			}
		}
	}

	private static void updateLegacyIndex(IProgressMonitor monitor) {
		SearchEngine engine = new SearchEngine();
		IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
		try {
			engine.searchAllTypeNames(
				null,
				SearchPattern.R_EXACT_MATCH,
				"!@$#!@".toCharArray(), //$NON-NLS-1$
				SearchPattern.R_PATTERN_MATCH | SearchPattern.R_CASE_SENSITIVE,
				IJavaSearchConstants.CLASS,
				scope,
				new TypeNameRequestor() {
					@Override
					public void acceptType(
						int modifiers,
						char[] packageName,
						char[] simpleTypeName,
						char[][] enclosingTypeNames,
						String path) {
						// no type to accept
					}
				},
				// will not activate index query caches if indexes are not ready, since it would take to long
				// to wait until indexes are fully rebuild
				IJavaSearchConstants.CANCEL_IF_NOT_READY_TO_SEARCH,
				monitor
			);
		} catch (JavaModelException e) {
			// /search failed: ignore
		} catch (OperationCanceledException e) {
			if (monitor.isCanceled())
				throw e;
			// else indexes were not ready: catch the exception so that jars are still refreshed
		}
	}

	
Returns whether a given classpath variable is read-only or not.
Params:
variableName – 
Returns:
true if the classpath variable is read-only,
	false otherwise.
Since:
3.3/**
	 * Returns whether a given classpath variable is read-only or not.
	 *
	 * @param variableName
	 * @return <code>true</code> if the classpath variable is read-only,
	 * 	<code>false</code> otherwise.
	 * @since 3.3
	 */
	public static boolean isClasspathVariableReadOnly(String variableName) {
	    return JavaModelManager.getJavaModelManager().readOnlyVariables.contains(variableName);
	}

	
Returns whether the given file name's extension is a Java-like extension.
See Also:
getJavaLikeExtensions()
Returns:
whether the given file name's extension is a Java-like extension
Since:
3.2/**
	 * Returns whether the given file name's extension is a Java-like extension.
	 *
	 * @return whether the given file name's extension is a Java-like extension
	 * @see #getJavaLikeExtensions()
	 * @since 3.2
	 */
	public static boolean isJavaLikeFileName(String fileName) {
		return Util.isJavaLikeFileName(fileName);
	}

	
Returns whether the given marker references the given Java element.
Used for markers, which denote a Java element rather than a resource.
Params:
element – the element
marker – the marker
Throws:
CoreException – if the IMarker.getAttribute on the marker fails
Returns:
true if the marker references the element, false otherwise/**
	 * Returns whether the given marker references the given Java element.
	 * Used for markers, which denote a Java element rather than a resource.
	 *
	 * @param element the element
	 * @param marker the marker
	 * @return <code>true</code> if the marker references the element, false otherwise
	 * @exception CoreException if the <code>IMarker.getAttribute</code> on the marker fails
	 */
	public static boolean isReferencedBy(IJavaElement element, IMarker marker) throws CoreException {

		// only match units or classfiles
		if (element instanceof IMember){
			IMember member = (IMember) element;
			if (member.isBinary()){
				element = member.getClassFile();
			} else {
				element = member.getCompilationUnit();
			}
		}
		if (element == null) return false;
		if (marker == null) return false;

		String markerHandleId = (String)marker.getAttribute(ATT_HANDLE_ID);
		if (markerHandleId == null) return false;

		IJavaElement markerElement = JavaCore.create(markerHandleId);
		while (true){
			if (element.equals(markerElement)) return true; // external elements may still be equal with different handleIDs.

			// cycle through enclosing types in case marker is associated with a classfile (15568)
			if (markerElement instanceof IOrdinaryClassFile){
				IType enclosingType = ((IOrdinaryClassFile)markerElement).getType().getDeclaringType();
				if (enclosingType != null){
					markerElement = enclosingType.getClassFile(); // retry with immediate enclosing classfile
					continue;
				}
			}
			break;
		}
		return false;
	}

	
Returns whether the given marker delta references the given Java element.
Used for markers deltas, which denote a Java element rather than a resource.
Params:
element – the element
markerDelta – the marker delta
Throws:
CoreException – if the  IMarkerDelta.getAttribute on the marker delta fails
Returns:
true if the marker delta references the element/**
	 * Returns whether the given marker delta references the given Java element.
	 * Used for markers deltas, which denote a Java element rather than a resource.
	 *
	 * @param element the element
	 * @param markerDelta the marker delta
	 * @return <code>true</code> if the marker delta references the element
	 * @exception CoreException if the  <code>IMarkerDelta.getAttribute</code> on the marker delta fails
	 */
	public static boolean isReferencedBy(IJavaElement element, IMarkerDelta markerDelta) throws CoreException {

		// only match units or classfiles
		if (element instanceof IMember){
			IMember member = (IMember) element;
			if (member.isBinary()){
				element = member.getClassFile();
			} else {
				element = member.getCompilationUnit();
			}
		}
		if (element == null) return false;
		if (markerDelta == null) return false;

		String markerDeltarHandleId = (String)markerDelta.getAttribute(ATT_HANDLE_ID);
		if (markerDeltarHandleId == null) return false;

		IJavaElement markerElement = JavaCore.create(markerDeltarHandleId);
		while (true){
			if (element.equals(markerElement)) return true; // external elements may still be equal with different handleIDs.

			// cycle through enclosing types in case marker is associated with a classfile (15568)
			if (markerElement instanceof IOrdinaryClassFile){
				IType enclosingType = ((IOrdinaryClassFile)markerElement).getType().getDeclaringType();
				if (enclosingType != null){
					markerElement = enclosingType.getClassFile(); // retry with immediate enclosing classfile
					continue;
				}
			}
			break;
		}
		return false;
	}

	
Creates and returns a new access rule with the given file pattern and kind.
 The rule kind is one of IAccessRule.K_ACCESSIBLE, IAccessRule.K_DISCOURAGED, or IAccessRule.K_NON_ACCESSIBLE, optionally combined with IAccessRule.IGNORE_IF_BETTER, e.g. IAccessRule.K_NON_ACCESSIBLE | IAccessRule.IGNORE_IF_BETTER.

Params:
filePattern – the file pattern this access rule should match
kind – one of IAccessRule.K_ACCESSIBLE, IAccessRule.K_DISCOURAGED, or IAccessRule.K_NON_ACCESSIBLE, optionally combined with IAccessRule.IGNORE_IF_BETTER
See Also:
IClasspathEntry.getExclusionPatterns()
Returns:
a new access rule
Since:
3.1/**
	 * Creates and returns a new access rule with the given file pattern and kind.
	 * <p>
	 * The rule kind is one of {@link IAccessRule#K_ACCESSIBLE}, {@link IAccessRule#K_DISCOURAGED},
	 * or {@link IAccessRule#K_NON_ACCESSIBLE}, optionally combined with {@link IAccessRule#IGNORE_IF_BETTER},
	 * e.g. <code>IAccessRule.K_NON_ACCESSIBLE | IAccessRule.IGNORE_IF_BETTER</code>.
	 * </p>
	 *
	 * @param filePattern the file pattern this access rule should match
	 * @param kind one of {@link IAccessRule#K_ACCESSIBLE}, {@link IAccessRule#K_DISCOURAGED},
	 *                     or {@link IAccessRule#K_NON_ACCESSIBLE}, optionally combined with
	 *                     {@link IAccessRule#IGNORE_IF_BETTER}
	 * @return a new access rule
	 * @since 3.1
	 * 
	 * @see IClasspathEntry#getExclusionPatterns()
	 */
	public static IAccessRule newAccessRule(IPath filePattern, int kind) {
		return JavaModelManager.getJavaModelManager().getAccessRule(filePattern, kind);
	}

	
Creates and returns a new classpath attribute with the given name and the given value.
Returns:
a new classpath attribute
Since:
3.1/**
	 * Creates and returns a new classpath attribute with the given name and the given value.
	 *
	 * @return a new classpath attribute
	 * @since 3.1
	 */
	public static IClasspathAttribute newClasspathAttribute(String name, String value) {
		return new ClasspathAttribute(name, value);
	}

	
Creates and returns a new classpath entry of kind CPE_CONTAINER for the given path. This method is fully equivalent to calling 
newContainerEntry(containerPath, new IAccessRule[0], new IClasspathAttribute[0], false). 
Params:
containerPath – the path identifying the container, it must be formed of two
	segments
See Also:
getClasspathContainer(IPath, IJavaProject)
Returns:
a new container classpath entry
Since:
2.0/**
	 * Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code>
	 * for the given path. This method is fully equivalent to calling
	 * {@link #newContainerEntry(IPath, IAccessRule[], IClasspathAttribute[], boolean)
	 * newContainerEntry(containerPath, new IAccessRule[0], new IClasspathAttribute[0], false)}.
	 *
	 * @param containerPath the path identifying the container, it must be formed of two
	 * 	segments
	 * @return a new container classpath entry
	 *
	 * @see JavaCore#getClasspathContainer(IPath, IJavaProject)
	 * @since 2.0
	 */
	public static IClasspathEntry newContainerEntry(IPath containerPath) {
		return newContainerEntry(
		containerPath,
		ClasspathEntry.NO_ACCESS_RULES,
		ClasspathEntry.NO_EXTRA_ATTRIBUTES,
		false/*not exported*/);
	}

	
Creates and returns a new classpath entry of kind CPE_CONTAINER for the given path. This method is fully equivalent to calling 
newContainerEntry(containerPath, new IAccessRule[0], new IClasspathAttribute[0], isExported). 
Params:
containerPath – the path identifying the container, it must be formed of at least
	one segment (ID+hints)
isExported – a boolean indicating whether this entry is contributed to dependent
   projects in addition to the output location
See Also:
getClasspathContainer(IPath, IJavaProject)
setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
Returns:
a new container classpath entry
Since:
2.0/**
	 * Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code>
	 * for the given path. This method is fully equivalent to calling
	 * {@link #newContainerEntry(IPath, IAccessRule[], IClasspathAttribute[], boolean)
	 * newContainerEntry(containerPath, new IAccessRule[0], new IClasspathAttribute[0], isExported)}.
	 *
	 * @param containerPath the path identifying the container, it must be formed of at least
	 * 	one segment (ID+hints)
	 * @param isExported a boolean indicating whether this entry is contributed to dependent
	 *    projects in addition to the output location
	 * @return a new container classpath entry
	 *
	 * @see JavaCore#getClasspathContainer(IPath, IJavaProject)
	 * @see JavaCore#setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
	 * @since 2.0
	 */
	public static IClasspathEntry newContainerEntry(IPath containerPath, boolean isExported) {
		return newContainerEntry(
			containerPath,
			ClasspathEntry.NO_ACCESS_RULES,
			ClasspathEntry.NO_EXTRA_ATTRIBUTES,
			isExported);
	}

	
Creates and returns a new classpath entry of kind CPE_CONTAINER
for the given path. The path of the container will be used during resolution so as to map this
container entry to a set of other classpath entries the container is acting for.

A container entry allows to express indirect references to a set of libraries, projects and variable entries,
which can be interpreted differently for each Java project where it is used.
A classpath container entry can be resolved using JavaCore.getResolvedClasspathContainer,
and updated with JavaCore.classpathContainerChanged


A container is exclusively resolved by a ClasspathContainerInitializer registered onto the
extension point "org.eclipse.jdt.core.classpathContainerInitializer".


A container path must be formed of at least one segment, where:


 the first segment is a unique ID identifying the target container, there must be a container initializer registered
	onto this ID through the extension point  "org.eclipse.jdt.core.classpathContainerInitializer". 
 the remaining segments will be passed onto the initializer, and can be used as additional
	hints during the initialization phase. 


Example of an ClasspathContainerInitializer for a classpath container denoting a default JDK container:

containerEntry = JavaCore.newContainerEntry(new Path("MyProvidedJDK/default"));
<extension
   point="org.eclipse.jdt.core.classpathContainerInitializer">
   <containerInitializer
      id="MyProvidedJDK"
      class="com.example.MyInitializer"/>

 The access rules determine the set of accessible source and class files in the container. If the list of access rules is empty, then all files in this container are accessible. See IAccessRule for a detailed description of access rules. Note that if an entry defined by the container defines access rules, then these access rules are combined with the given access rules. The given access rules are considered first, then the entry's access rules are considered. 

The extraAttributes list contains name/value pairs that must be persisted with
this entry. If no extra attributes are provided, an empty array must be passed in.

Note that this list should not contain any duplicate name.


The isExported flag indicates whether this entry is contributed to dependent
projects. If not exported, dependent projects will not see any of the classes from this entry.
If exported, dependent projects will concatenate the accessible files patterns of this entry with the
accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
with the non accessible files patterns of the project.


Note that this operation does not attempt to validate classpath containers
or access the resources at the given paths.

Params:
containerPath – the path identifying the container, it must be formed of at least
	one segment (ID+hints)
accessRules – the possibly empty list of access rules for this entry
extraAttributes – the possibly empty list of extra attributes to persist with this entry
isExported – a boolean indicating whether this entry is contributed to dependent
   projects in addition to the output location
See Also:
getClasspathContainer(IPath, IJavaProject)
setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
newContainerEntry(IPath, boolean)
newAccessRule(IPath, int)
Returns:
a new container classpath entry
Since:
3.1/**
	 * Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code>
	 * for the given path. The path of the container will be used during resolution so as to map this
	 * container entry to a set of other classpath entries the container is acting for.
	 * <p>
	 * A container entry allows to express indirect references to a set of libraries, projects and variable entries,
	 * which can be interpreted differently for each Java project where it is used.
	 * A classpath container entry can be resolved using <code>JavaCore.getResolvedClasspathContainer</code>,
	 * and updated with <code>JavaCore.classpathContainerChanged</code>
	 * </p>
	 * <p>
	 * A container is exclusively resolved by a <code>ClasspathContainerInitializer</code> registered onto the
	 * extension point "org.eclipse.jdt.core.classpathContainerInitializer".
	 * </p>
	 * <p>
	 * A container path must be formed of at least one segment, where:
	 * </p>
	 * <ul>
	 * <li> the first segment is a unique ID identifying the target container, there must be a container initializer registered
	 * 	onto this ID through the extension point  "org.eclipse.jdt.core.classpathContainerInitializer". </li>
	 * <li> the remaining segments will be passed onto the initializer, and can be used as additional
	 * 	hints during the initialization phase. </li>
	 * </ul>
	 * <p>
	 * Example of an ClasspathContainerInitializer for a classpath container denoting a default JDK container:
	 * </p>
	 * <pre>
	 * containerEntry = JavaCore.newContainerEntry(new Path("MyProvidedJDK/default"));
	 *
	 * &lt;extension
	 *    point="org.eclipse.jdt.core.classpathContainerInitializer"&gt;
	 *    &lt;containerInitializer
	 *       id="MyProvidedJDK"
	 *       class="com.example.MyInitializer"/&gt;
	 * </pre>
	 * <p>
	 * The access rules determine the set of accessible source and class files
	 * in the container. If the list of access rules is empty, then all files
	 * in this container are accessible.
	 * See {@link IAccessRule} for a detailed description of access
	 * rules. Note that if an entry defined by the container defines access rules,
	 * then these access rules are combined with the given access rules.
	 * The given access rules are considered first, then the entry's access rules are
	 * considered.
	 * </p>
	 * <p>
	 * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
	 * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
	 * Note that this list should not contain any duplicate name.
	 * </p>
	 * <p>
	 * The <code>isExported</code> flag indicates whether this entry is contributed to dependent
	 * projects. If not exported, dependent projects will not see any of the classes from this entry.
	 * If exported, dependent projects will concatenate the accessible files patterns of this entry with the
	 * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
	 * with the non accessible files patterns of the project.
	 * </p>
	 * <p>
	 * Note that this operation does not attempt to validate classpath containers
	 * or access the resources at the given paths.
	 * </p>
	 *
	 * @param containerPath the path identifying the container, it must be formed of at least
	 * 	one segment (ID+hints)
	 * @param accessRules the possibly empty list of access rules for this entry
	 * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
	 * @param isExported a boolean indicating whether this entry is contributed to dependent
	 *    projects in addition to the output location
	 * @return a new container classpath entry
	 *
	 * @see JavaCore#getClasspathContainer(IPath, IJavaProject)
	 * @see JavaCore#setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
	 * @see JavaCore#newContainerEntry(IPath, boolean)
	 * @see JavaCore#newAccessRule(IPath, int)
	 * @since 3.1
	 */
	public static IClasspathEntry newContainerEntry(
			IPath containerPath,
			IAccessRule[] accessRules,
			IClasspathAttribute[] extraAttributes,
			boolean isExported) {

		if (containerPath == null) {
			throw new ClasspathEntry.AssertionFailedException("Container path cannot be null"); //$NON-NLS-1$
		} else if (containerPath.segmentCount() < 1) {
			throw new ClasspathEntry.AssertionFailedException("Illegal classpath container path: \'" + containerPath.makeRelative().toString() + "\', must have at least one segment (containerID+hints)"); //$NON-NLS-1$//$NON-NLS-2$
		}
		if (accessRules == null || accessRules.length == 0) {
			accessRules = ClasspathEntry.NO_ACCESS_RULES;
		}
		if (extraAttributes == null || extraAttributes.length == 0) {
			extraAttributes = ClasspathEntry.NO_EXTRA_ATTRIBUTES;
		}
		return new ClasspathEntry(
			IPackageFragmentRoot.K_SOURCE,
			IClasspathEntry.CPE_CONTAINER,
			containerPath,
			ClasspathEntry.INCLUDE_ALL, // inclusion patterns
			ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
			null, // source attachment
			null, // source attachment root
			null, // specific output folder
			isExported,
			accessRules,
			true, // combine access rules
			extraAttributes);
	}

	
Creates and returns a type hierarchy for all types in the given
region, considering subtypes within that region and considering types in the
working copies with the given owner.
In other words, the owner's working copies will take
precedence over their original compilation units in the workspace.

Note that if a working copy is empty, it will be as if the original compilation
unit had been deleted.

Params:
monitor – the given progress monitor
region – the given region
owner – the owner of working copies that take precedence over their original compilation units,
  or null if the primary working copy owner should be used
Throws:
JavaModelException – if an element in the region does not exist or if an
	exception occurs while accessing its corresponding resource
IllegalArgumentException – if region is null
Returns:
a type hierarchy for all types in the given
region, considering subtypes within that region
Since:
3.1/**
	 * Creates and returns a type hierarchy for all types in the given
	 * region, considering subtypes within that region and considering types in the
	 * working copies with the given owner.
	 * In other words, the owner's working copies will take
	 * precedence over their original compilation units in the workspace.
	 * <p>
	 * Note that if a working copy is empty, it will be as if the original compilation
	 * unit had been deleted.
	 * </p>
	 *
	 * @param monitor the given progress monitor
	 * @param region the given region
	 * @param owner the owner of working copies that take precedence over their original compilation units,
	 *   or <code>null</code> if the primary working copy owner should be used
	 * @exception JavaModelException if an element in the region does not exist or if an
	 *		exception occurs while accessing its corresponding resource
	 * @exception IllegalArgumentException if region is <code>null</code>
	 * @return a type hierarchy for all types in the given
	 * region, considering subtypes within that region
	 * @since 3.1
	 */
	public static ITypeHierarchy newTypeHierarchy(IRegion region, WorkingCopyOwner owner, IProgressMonitor monitor) throws JavaModelException {
		if (region == null) {
			throw new IllegalArgumentException(Messages.hierarchy_nullRegion);
		}
		ICompilationUnit[] workingCopies = JavaModelManager.getJavaModelManager().getWorkingCopies(owner, true/*add primary working copies*/);
		CreateTypeHierarchyOperation op =
			new CreateTypeHierarchyOperation(region, workingCopies, null, true/*compute subtypes*/);
		op.runOperation(monitor);
		return op.getResult();
	}

	
Creates and returns a new non-exported classpath entry of kind CPE_LIBRARY for the
JAR or folder identified by the given absolute path. This specifies that all package fragments
within the root will have children of type IClassFile. This method is fully equivalent to calling 
newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], false). 
Params:
path – the path to the library
sourceAttachmentPath – the absolute path of the corresponding source archive or folder,
   or null if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
   Since 3.4, this path can also denote a path external to the workspace.
  and will be automatically converted to null.
sourceAttachmentRootPath – the location of the root of the source files within the source archive or folder
   or null if this location should be automatically detected.
Returns:
a new library classpath entry/**
	 * Creates and returns a new non-exported classpath entry of kind <code>CPE_LIBRARY</code> for the
	 * JAR or folder identified by the given absolute path. This specifies that all package fragments
	 * within the root will have children of type <code>IClassFile</code>.
	 * This method is fully equivalent to calling
	 * {@link #newLibraryEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
	 * newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], false)}.
	 *
	 * @param path the path to the library
	 * @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
	 *    or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
	 *    Since 3.4, this path can also denote a path external to the workspace.
	 *   and will be automatically converted to <code>null</code>.
	 * @param sourceAttachmentRootPath the location of the root of the source files within the source archive or folder
	 *    or <code>null</code> if this location should be automatically detected.
	 * @return a new library classpath entry
	 */
	public static IClasspathEntry newLibraryEntry(
		IPath path,
		IPath sourceAttachmentPath,
		IPath sourceAttachmentRootPath) {

		return newLibraryEntry(
			path,
			sourceAttachmentPath,
			sourceAttachmentRootPath,
			ClasspathEntry.NO_ACCESS_RULES,
			ClasspathEntry.NO_EXTRA_ATTRIBUTES,
			false/*not exported*/);
	}

	
Creates and returns a new classpath entry of kind CPE_LIBRARY for the JAR or folder
identified by the given absolute path. This specifies that all package fragments within the root
will have children of type IClassFile.
 This method is fully equivalent to calling 
newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], isExported). 
Params:
path – the path to the library
sourceAttachmentPath – the absolute path of the corresponding source archive or folder,
   or null if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
  and will be automatically converted to null. Since 3.4, this path can also denote a path external
  to the workspace.
sourceAttachmentRootPath – the location of the root of the source files within the source archive or folder
   or null if this location should be automatically detected.
isExported – indicates whether this entry is contributed to dependent
	  projects in addition to the output location
Returns:
a new library classpath entry
Since:
2.0/**
	 * Creates and returns a new classpath entry of kind <code>CPE_LIBRARY</code> for the JAR or folder
	 * identified by the given absolute path. This specifies that all package fragments within the root
	 * will have children of type <code>IClassFile</code>.
	 * <p>
	 * This method is fully equivalent to calling
	 * {@link #newLibraryEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
	 * newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], isExported)}.
	 * </p>
	 *
	 * @param path the path to the library
	 * @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
	 *    or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
	 *   and will be automatically converted to <code>null</code>. Since 3.4, this path can also denote a path external
	 *   to the workspace.
	 * @param sourceAttachmentRootPath the location of the root of the source files within the source archive or folder
	 *    or <code>null</code> if this location should be automatically detected.
	 * @param isExported indicates whether this entry is contributed to dependent
	 * 	  projects in addition to the output location
	 * @return a new library classpath entry
	 * @since 2.0
	 */
	public static IClasspathEntry newLibraryEntry(
		IPath path,
		IPath sourceAttachmentPath,
		IPath sourceAttachmentRootPath,
		boolean isExported) {

		return newLibraryEntry(
			path,
			sourceAttachmentPath,
			sourceAttachmentRootPath,
			ClasspathEntry.NO_ACCESS_RULES,
			ClasspathEntry.NO_EXTRA_ATTRIBUTES,
			isExported);
	}

	
Creates and returns a new classpath entry of kind CPE_LIBRARY for the JAR or folder
identified by the given absolute path. This specifies that all package fragments within the root
will have children of type IClassFile.

A library entry is used to denote a prerequisite JAR or root folder containing binaries.
The target JAR can either be defined internally to the workspace (absolute path relative
to the workspace root), or externally to the workspace (absolute path in the file system).
The target root folder can also be defined internally to the workspace (absolute path relative
to the workspace root), or - since 3.4 - externally to the workspace (absolute path in the file system).
Since 3.5, the path to the library can also be relative to the project using ".." as the first segment. 


e.g. Here are some examples of binary path usage


 "c:\jdk1.2.2\jre\lib\rt.jar"  - reference to an external JAR on Windows
 "/Project/someLib.jar"  - reference to an internal JAR on Windows or Linux
 "/Project/classes/"  - reference to an internal binary folder on Windows or Linux
 "/home/usr/classes"  - reference to an external binary folder on Linux
 "../../lib/someLib.jar"  - reference to an external JAR that is a sibling of the workspace on either platform

Note that on non-Windows platform, a path "/some/lib.jar" is ambiguous.
It can be a path to an external JAR (its file system path being "/some/lib.jar")
or it can be a path to an internal JAR ("some" being a project in the workspace). Such an ambiguity is solved when the classpath entry is used (e.g. in IJavaProject.getPackageFragmentRoots()). If the resource "lib.jar" exists in project "some", then it is considered an
internal JAR. Otherwise it is an external JAR.
Also note that this operation does not attempt to validate or access the
resources at the given paths.
 The access rules determine the set of accessible class files in the library. If the list of access rules is empty then all files in this library are accessible. See IAccessRule for a detailed description of access rules. 

The extraAttributes list contains name/value pairs that must be persisted with
this entry. If no extra attributes are provided, an empty array must be passed in.

Note that this list should not contain any duplicate name.


The isExported flag indicates whether this entry is contributed to dependent
projects. If not exported, dependent projects will not see any of the classes from this entry.
If exported, dependent projects will concatenate the accessible files patterns of this entry with the
accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
with the non accessible files patterns of the project.

 Since 3.5, if the library is a ZIP archive, the "Class-Path" clause (if any) in the "META-INF/MANIFEST.MF" is read and referenced ZIP archives are added to the resolved classpath. 
Params:
path – the path to the library
sourceAttachmentPath – the absolute path of the corresponding source archive or folder,
   or null if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
  and will be automatically converted to null. Since 3.4, this path can also denote a path external
  to the workspace.
sourceAttachmentRootPath – the location of the root of the source files within the source archive or folder
   or null if this location should be automatically detected.
accessRules – the possibly empty list of access rules for this entry
extraAttributes – the possibly empty list of extra attributes to persist with this entry
isExported – indicates whether this entry is contributed to dependent
	  projects in addition to the output location
Returns:
a new library classpath entry
Since:
3.1/**
	 * Creates and returns a new classpath entry of kind <code>CPE_LIBRARY</code> for the JAR or folder
	 * identified by the given absolute path. This specifies that all package fragments within the root
	 * will have children of type <code>IClassFile</code>.
	 * <p>
	 * A library entry is used to denote a prerequisite JAR or root folder containing binaries.
	 * The target JAR can either be defined internally to the workspace (absolute path relative
	 * to the workspace root), or externally to the workspace (absolute path in the file system).
	 * The target root folder can also be defined internally to the workspace (absolute path relative
	 * to the workspace root), or - since 3.4 - externally to the workspace (absolute path in the file system).
	 * Since 3.5, the path to the library can also be relative to the project using ".." as the first segment. 
	 * </p>
	 * <p>
	 * e.g. Here are some examples of binary path usage
	 * </p>
	 *	<ul>
	 *	<li><code> "c:\jdk1.2.2\jre\lib\rt.jar" </code> - reference to an external JAR on Windows</li>
	 *	<li><code> "/Project/someLib.jar" </code> - reference to an internal JAR on Windows or Linux</li>
	 *	<li><code> "/Project/classes/" </code> - reference to an internal binary folder on Windows or Linux</li>
	 *	<li><code> "/home/usr/classes" </code> - reference to an external binary folder on Linux</li>
	 *	<li><code> "../../lib/someLib.jar" </code> - reference to an external JAR that is a sibling of the workspace on either platform</li>
	 * </ul>
	 * Note that on non-Windows platform, a path <code>"/some/lib.jar"</code> is ambiguous.
	 * It can be a path to an external JAR (its file system path being <code>"/some/lib.jar"</code>)
	 * or it can be a path to an internal JAR (<code>"some"</code> being a project in the workspace).
	 * Such an ambiguity is solved when the classpath entry is used (e.g. in {@link IJavaProject#getPackageFragmentRoots()}).
	 * If the resource <code>"lib.jar"</code> exists in project <code>"some"</code>, then it is considered an
	 * internal JAR. Otherwise it is an external JAR.
	 * <p>Also note that this operation does not attempt to validate or access the
	 * resources at the given paths.
	 * </p><p>
	 * The access rules determine the set of accessible class files
	 * in the library. If the list of access rules is empty then all files
	 * in this library are accessible.
	 * See {@link IAccessRule} for a detailed description of access
	 * rules.
	 * </p>
	 * <p>
	 * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
	 * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
	 * Note that this list should not contain any duplicate name.
	 * </p>
	 * <p>
	 * The <code>isExported</code> flag indicates whether this entry is contributed to dependent
	 * projects. If not exported, dependent projects will not see any of the classes from this entry.
	 * If exported, dependent projects will concatenate the accessible files patterns of this entry with the
	 * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
	 * with the non accessible files patterns of the project.
	 * </p>
	 * <p>
	 * Since 3.5, if the library is a ZIP archive, the "Class-Path" clause (if any) in the "META-INF/MANIFEST.MF" is read
	 * and referenced ZIP archives are added to the {@link IJavaProject#getResolvedClasspath(boolean) resolved classpath}.
	 * </p>
	 *
	 * @param path the path to the library
	 * @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
	 *    or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
	 *   and will be automatically converted to <code>null</code>. Since 3.4, this path can also denote a path external
	 *   to the workspace.
	 * @param sourceAttachmentRootPath the location of the root of the source files within the source archive or folder
	 *    or <code>null</code> if this location should be automatically detected.
	 * @param accessRules the possibly empty list of access rules for this entry
	 * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
	 * @param isExported indicates whether this entry is contributed to dependent
	 * 	  projects in addition to the output location
	 * @return a new library classpath entry
	 * @since 3.1
	 */
	public static IClasspathEntry newLibraryEntry(
			IPath path,
			IPath sourceAttachmentPath,
			IPath sourceAttachmentRootPath,
			IAccessRule[] accessRules,
			IClasspathAttribute[] extraAttributes,
			boolean isExported) {

		if (path == null) throw new ClasspathEntry.AssertionFailedException("Library path cannot be null"); //$NON-NLS-1$
		if (accessRules == null || accessRules.length==0) {
			accessRules = ClasspathEntry.NO_ACCESS_RULES;
		}
		if (extraAttributes == null || extraAttributes.length==0) {
			extraAttributes = ClasspathEntry.NO_EXTRA_ATTRIBUTES;
		}
		boolean hasDotDot = ClasspathEntry.hasDotDot(path);
		if (!hasDotDot && !path.isAbsolute()) throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute: " + path); //$NON-NLS-1$
		if (sourceAttachmentPath != null) {
			if (sourceAttachmentPath.isEmpty()) {
				sourceAttachmentPath = null; // treat empty path as none
			} else if (!sourceAttachmentPath.isAbsolute()) {
				throw new ClasspathEntry.AssertionFailedException("Source attachment path '" //$NON-NLS-1$
						+ sourceAttachmentPath
						+ "' for IClasspathEntry must be absolute"); //$NON-NLS-1$
			}
		}
		return new ClasspathEntry(
			IPackageFragmentRoot.K_BINARY,
			IClasspathEntry.CPE_LIBRARY,
			hasDotDot ? path : JavaProject.canonicalizedPath(path),
			ClasspathEntry.INCLUDE_ALL, // inclusion patterns
			ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
			sourceAttachmentPath,
			sourceAttachmentRootPath,
			null, // specific output folder
			isExported,
			accessRules,
			false, // no access rules to combine
			extraAttributes);
	}

	
Creates and returns a new non-exported classpath entry of kind CPE_PROJECT
for the project identified by the given absolute path.
 This method is fully equivalent to calling 
newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], false). 
Params:
path – the absolute path of the binary archive
Returns:
a new project classpath entry/**
	 * Creates and returns a new non-exported classpath entry of kind <code>CPE_PROJECT</code>
	 * for the project identified by the given absolute path.
	 * <p>
	 * This method is fully equivalent to calling
	 * {@link #newProjectEntry(IPath, IAccessRule[], boolean, IClasspathAttribute[], boolean)
	 * newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], false)}.
	 * </p>
	 *
	 * @param path the absolute path of the binary archive
	 * @return a new project classpath entry
	 */
	public static IClasspathEntry newProjectEntry(IPath path) {
		return newProjectEntry(path, false);
	}

	
Creates and returns a new classpath entry of kind CPE_PROJECT
for the project identified by the given absolute path.
 This method is fully equivalent to calling 
newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], isExported). 
Params:
path – the absolute path of the prerequisite project
isExported – indicates whether this entry is contributed to dependent
	  projects in addition to the output location
Returns:
a new project classpath entry
Since:
2.0/**
	 * Creates and returns a new classpath entry of kind <code>CPE_PROJECT</code>
	 * for the project identified by the given absolute path.
	 * <p>
	 * This method is fully equivalent to calling
	 * {@link #newProjectEntry(IPath, IAccessRule[], boolean, IClasspathAttribute[], boolean)
	 * newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], isExported)}.
	 * </p>
	 *
	 * @param path the absolute path of the prerequisite project
	 * @param isExported indicates whether this entry is contributed to dependent
	 * 	  projects in addition to the output location
	 * @return a new project classpath entry
	 * @since 2.0
	 */
	public static IClasspathEntry newProjectEntry(IPath path, boolean isExported) {

		if (!path.isAbsolute()) throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute"); //$NON-NLS-1$

		return newProjectEntry(
			path,
			ClasspathEntry.NO_ACCESS_RULES,
			true,
			ClasspathEntry.NO_EXTRA_ATTRIBUTES,
			isExported);
	}

	
Creates and returns a new classpath entry of kind CPE_PROJECT
for the project identified by the given absolute path.

A project entry is used to denote a prerequisite project on a classpath.
The referenced project will be contributed as a whole, either as sources (in the Java Model, it
contributes all its package fragment roots) or as binaries (when building, it contributes its
whole output location).


A project reference allows to indirect through another project, independently from its internal layout.

The prerequisite project is referred to using an absolute path relative to the workspace root.

 The access rules determine the set of accessible class files in the project. If the list of access rules is empty then all files in this project are accessible. See IAccessRule for a detailed description of access rules. 

The combineAccessRules flag indicates whether access rules of one (or more)
exported entry of the project should be combined with the given access rules. If they should
be combined, the given access rules are considered first, then the entry's access rules are
considered.


The extraAttributes list contains name/value pairs that must be persisted with
this entry. If no extra attributes are provided, an empty array must be passed in.

Note that this list should not contain any duplicate name.


The isExported flag indicates whether this entry is contributed to dependent
projects. If not exported, dependent projects will not see any of the classes from this entry.
If exported, dependent projects will concatenate the accessible files patterns of this entry with the
accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
with the non accessible files patterns of the project.

Params:
path – the absolute path of the prerequisite project
accessRules – the possibly empty list of access rules for this entry
combineAccessRules – whether the access rules of the project's exported entries should be combined with the given access rules
extraAttributes – the possibly empty list of extra attributes to persist with this entry
isExported – indicates whether this entry is contributed to dependent
	  projects in addition to the output location
Returns:
a new project classpath entry
Since:
3.1/**
	 * Creates and returns a new classpath entry of kind <code>CPE_PROJECT</code>
	 * for the project identified by the given absolute path.
	 * <p>
	 * A project entry is used to denote a prerequisite project on a classpath.
	 * The referenced project will be contributed as a whole, either as sources (in the Java Model, it
	 * contributes all its package fragment roots) or as binaries (when building, it contributes its
	 * whole output location).
	 * </p>
	 * <p>
	 * A project reference allows to indirect through another project, independently from its internal layout.
	 * </p><p>
	 * The prerequisite project is referred to using an absolute path relative to the workspace root.
	 * </p>
	 * <p>
	 * The access rules determine the set of accessible class files
	 * in the project. If the list of access rules is empty then all files
	 * in this project are accessible.
	 * See {@link IAccessRule} for a detailed description of access rules.
	 * </p>
	 * <p>
	 * The <code>combineAccessRules</code> flag indicates whether access rules of one (or more)
	 * exported entry of the project should be combined with the given access rules. If they should
	 * be combined, the given access rules are considered first, then the entry's access rules are
	 * considered.
	 * </p>
	 * <p>
	 * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
	 * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
	 * Note that this list should not contain any duplicate name.
	 * </p>
	 * <p>
	 * The <code>isExported</code> flag indicates whether this entry is contributed to dependent
	 * projects. If not exported, dependent projects will not see any of the classes from this entry.
	 * If exported, dependent projects will concatenate the accessible files patterns of this entry with the
	 * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
	 * with the non accessible files patterns of the project.
	 * </p>
	 *
	 * @param path the absolute path of the prerequisite project
	 * @param accessRules the possibly empty list of access rules for this entry
	 * @param combineAccessRules whether the access rules of the project's exported entries should be combined with the given access rules
	 * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
	 * @param isExported indicates whether this entry is contributed to dependent
	 * 	  projects in addition to the output location
	 * @return a new project classpath entry
	 * @since 3.1
	 */
	public static IClasspathEntry newProjectEntry(
			IPath path,
			IAccessRule[] accessRules,
			boolean combineAccessRules,
			IClasspathAttribute[] extraAttributes,
			boolean isExported) {

		if (!path.isAbsolute()) throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
		if (accessRules == null || accessRules.length == 0) {
			accessRules = ClasspathEntry.NO_ACCESS_RULES;
		}
		if (extraAttributes == null || extraAttributes.length == 0) {
			extraAttributes = ClasspathEntry.NO_EXTRA_ATTRIBUTES;
		}
		return new ClasspathEntry(
			IPackageFragmentRoot.K_SOURCE,
			IClasspathEntry.CPE_PROJECT,
			path,
			ClasspathEntry.INCLUDE_ALL, // inclusion patterns
			ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
			null, // source attachment
			null, // source attachment root
			null, // specific output folder
			isExported,
			accessRules,
			combineAccessRules,
			extraAttributes);
	}

	
Returns a new empty region.
Returns:
a new empty region/**
	 * Returns a new empty region.
	 *
	 * @return a new empty region
	 */
	public static IRegion newRegion() {
		return new Region();
	}

	
Creates and returns a new classpath entry of kind CPE_SOURCE
for all files in the project's source folder identified by the given
absolute workspace-relative path.

The convenience method is fully equivalent to:

newSourceEntry(path, new IPath[] {}, new IPath[] {}, null);

Params:
path – the absolute workspace-relative path of a source folder
See Also:
newSourceEntry(IPath, IPath[], IPath[], IPath)
Returns:
a new source classpath entry/**
	 * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
	 * for all files in the project's source folder identified by the given
	 * absolute workspace-relative path.
	 * <p>
	 * The convenience method is fully equivalent to:
	 * </p>
	 * <pre>
	 * newSourceEntry(path, new IPath[] {}, new IPath[] {}, null);
	 * </pre>
	 *
	 * @param path the absolute workspace-relative path of a source folder
	 * @return a new source classpath entry
	 * @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
	 */
	public static IClasspathEntry newSourceEntry(IPath path) {

		return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, ClasspathEntry.EXCLUDE_NONE, null /*output location*/);
	}

	
Creates and returns a new classpath entry of kind CPE_SOURCE
for the project's source folder identified by the given absolute
workspace-relative path but excluding all source files with paths
matching any of the given patterns.

The convenience method is fully equivalent to:

newSourceEntry(path, new IPath[] {}, exclusionPatterns, null);

Params:
path – the absolute workspace-relative path of a source folder
exclusionPatterns – the possibly empty list of exclusion patterns
   represented as relative paths
See Also:
newSourceEntry(IPath, IPath[], IPath[], IPath)
Returns:
a new source classpath entry
Since:
2.1/**
	 * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
	 * for the project's source folder identified by the given absolute
	 * workspace-relative path but excluding all source files with paths
	 * matching any of the given patterns.
	 * <p>
	 * The convenience method is fully equivalent to:
	 * </p>
	 * <pre>
	 * newSourceEntry(path, new IPath[] {}, exclusionPatterns, null);
	 * </pre>
	 *
	 * @param path the absolute workspace-relative path of a source folder
	 * @param exclusionPatterns the possibly empty list of exclusion patterns
	 *    represented as relative paths
	 * @return a new source classpath entry
	 * @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
	 * @since 2.1
	 */
	public static IClasspathEntry newSourceEntry(IPath path, IPath[] exclusionPatterns) {

		return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, exclusionPatterns, null /*output location*/);
	}

	
Creates and returns a new classpath entry of kind CPE_SOURCE
for the project's source folder identified by the given absolute
workspace-relative path but excluding all source files with paths
matching any of the given patterns, and associated with a specific output location
(that is, ".class" files are not going to the project default output location).

The convenience method is fully equivalent to:

newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation);

Params:
path – the absolute workspace-relative path of a source folder
exclusionPatterns – the possibly empty list of exclusion patterns
   represented as relative paths
specificOutputLocation – the specific output location for this source entry (null if using project default output location)
See Also:
newSourceEntry(IPath, IPath[], IPath[], IPath)
Returns:
a new source classpath entry
Since:
2.1/**
	 * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
	 * for the project's source folder identified by the given absolute
	 * workspace-relative path but excluding all source files with paths
	 * matching any of the given patterns, and associated with a specific output location
	 * (that is, ".class" files are not going to the project default output location).
	 * <p>
	 * The convenience method is fully equivalent to:
	 * </p>
	 * <pre>
	 * newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation);
	 * </pre>
	 *
	 * @param path the absolute workspace-relative path of a source folder
	 * @param exclusionPatterns the possibly empty list of exclusion patterns
	 *    represented as relative paths
	 * @param specificOutputLocation the specific output location for this source entry (<code>null</code> if using project default output location)
	 * @return a new source classpath entry
	 * @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
	 * @since 2.1
	 */
	public static IClasspathEntry newSourceEntry(IPath path, IPath[] exclusionPatterns, IPath specificOutputLocation) {

	    return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, exclusionPatterns, specificOutputLocation);
	}

	
Creates and returns a new classpath entry of kind CPE_SOURCE
for the project's source folder identified by the given absolute
workspace-relative path but excluding all source files with paths
matching any of the given patterns, and associated with a specific output location
(that is, ".class" files are not going to the project default output location).

The convenience method is fully equivalent to:

newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation, new IClasspathAttribute[] {});

Params:
path – the absolute workspace-relative path of a source folder
inclusionPatterns – the possibly empty list of inclusion patterns
   represented as relative paths
exclusionPatterns – the possibly empty list of exclusion patterns
   represented as relative paths
specificOutputLocation – the specific output location for this source entry (null if using project default output location)
See Also:
newSourceEntry(IPath, IPath[], IPath[], IPath, IClasspathAttribute[])
Returns:
a new source classpath entry
Since:
3.0/**
	 * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
	 * for the project's source folder identified by the given absolute
	 * workspace-relative path but excluding all source files with paths
	 * matching any of the given patterns, and associated with a specific output location
	 * (that is, ".class" files are not going to the project default output location).
	 * <p>
	 * The convenience method is fully equivalent to:
	 * </p>
	 * <pre>
	 * newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation, new IClasspathAttribute[] {});
	 * </pre>
	 *
	 * @param path the absolute workspace-relative path of a source folder
	 * @param inclusionPatterns the possibly empty list of inclusion patterns
	 *    represented as relative paths
	 * @param exclusionPatterns the possibly empty list of exclusion patterns
	 *    represented as relative paths
	 * @param specificOutputLocation the specific output location for this source entry (<code>null</code> if using project default output location)
	 * @return a new source classpath entry
	 * @see #newSourceEntry(IPath, IPath[], IPath[], IPath, IClasspathAttribute[])
	 * @since 3.0
	 */
	public static IClasspathEntry newSourceEntry(IPath path, IPath[] inclusionPatterns, IPath[] exclusionPatterns, IPath specificOutputLocation) {
		return newSourceEntry(path, inclusionPatterns, exclusionPatterns, specificOutputLocation, ClasspathEntry.NO_EXTRA_ATTRIBUTES);
	}

	
Creates and returns a new classpath entry of kind CPE_SOURCE
for the project's source folder identified by the given absolute
workspace-relative path using the given inclusion and exclusion patterns
to determine which source files are included, and the given output path
to control the output location of generated files.

The source folder is referred to using an absolute path relative to the
workspace root, e.g. /Project/src. A project's source
folders are located with that project. That is, a source classpath
entry specifying the path /P1/src is only usable for
project P1.


The inclusion patterns determines the initial set of source files that
are to be included; the exclusion patterns are then used to reduce this
set. When no inclusion patterns are specified, the initial file set
includes all relevant files in the resource tree rooted at the source
entry's path. On the other hand, specifying one or more inclusion
patterns means that all and only files matching at least one of the specified patterns are to be included. If exclusion patterns are specified, the initial set of files is then reduced by eliminating files matched by at least one of the exclusion patterns. Inclusion and exclusion patterns look like relative file paths with wildcards and are interpreted relative to the source entry's path. File patterns are case-sensitive can contain '**', '*' or '?' wildcards (see IClasspathEntry.getExclusionPatterns() for the full description of their syntax and semantics). The resulting set of files are included in the corresponding package fragment root; all package fragments within the root will have children of type ICompilationUnit.


For example, if the source folder path is
/Project/src, there are no inclusion filters, and the
exclusion pattern is
com/xyz/tests/**, then source files
like /Project/src/com/xyz/Foo.java
and /Project/src/com/xyz/utils/Bar.java would be included,
whereas /Project/src/com/xyz/tests/T1.java
and /Project/src/com/xyz/tests/quick/T2.java would be
excluded.


Additionally, a source entry can be associated with a specific output location.
By doing so, the Java builder will ensure that the generated ".class" files will
be issued inside this output location, as opposed to be generated into the
project default output location (when output location is null).
Note that multiple source entries may target the same output location.
The output location is referred to using an absolute path relative to the
workspace root, e.g. "/Project/bin", it must be located inside
the same project as the source folder.


Also note that all sources/binaries inside a project are contributed as
a whole through a project entry
(see JavaCore.newProjectEntry). Particular source entries
cannot be selectively exported.


The extraAttributes list contains name/value pairs that must be persisted with
this entry. If no extra attributes are provided, an empty array must be passed in.

Note that this list should not contain any duplicate name.

Params:
path – the absolute workspace-relative path of a source folder
inclusionPatterns – the possibly empty list of inclusion patterns
   represented as relative paths
exclusionPatterns – the possibly empty list of exclusion patterns
   represented as relative paths
specificOutputLocation – the specific output location for this source entry (null if using project default ouput location)
extraAttributes – the possibly empty list of extra attributes to persist with this entry
See Also:
IClasspathEntry.getInclusionPatterns()
IClasspathEntry.getExclusionPatterns()
IClasspathEntry.getOutputLocation()
Returns:
a new source classpath entry with the given exclusion patterns
Since:
3.1/**
	 * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
	 * for the project's source folder identified by the given absolute
	 * workspace-relative path using the given inclusion and exclusion patterns
	 * to determine which source files are included, and the given output path
	 * to control the output location of generated files.
	 * <p>
	 * The source folder is referred to using an absolute path relative to the
	 * workspace root, e.g. <code>/Project/src</code>. A project's source
	 * folders are located with that project. That is, a source classpath
	 * entry specifying the path <code>/P1/src</code> is only usable for
	 * project <code>P1</code>.
	 * </p>
	 * <p>
	 * The inclusion patterns determines the initial set of source files that
	 * are to be included; the exclusion patterns are then used to reduce this
	 * set. When no inclusion patterns are specified, the initial file set
	 * includes all relevant files in the resource tree rooted at the source
	 * entry's path. On the other hand, specifying one or more inclusion
	 * patterns means that all <b>and only</b> files matching at least one of
	 * the specified patterns are to be included. If exclusion patterns are
	 * specified, the initial set of files is then reduced by eliminating files
	 * matched by at least one of the exclusion patterns. Inclusion and
	 * exclusion patterns look like relative file paths with wildcards and are
	 * interpreted relative to the source entry's path. File patterns are
	 * case-sensitive can contain '**', '*' or '?' wildcards (see
	 * {@link IClasspathEntry#getExclusionPatterns()} for the full description
	 * of their syntax and semantics). The resulting set of files are included
	 * in the corresponding package fragment root; all package fragments within
	 * the root will have children of type <code>ICompilationUnit</code>.
	 * </p>
	 * <p>
	 * For example, if the source folder path is
	 * <code>/Project/src</code>, there are no inclusion filters, and the
	 * exclusion pattern is
	 * <code>com/xyz/tests/&#42;&#42;</code>, then source files
	 * like <code>/Project/src/com/xyz/Foo.java</code>
	 * and <code>/Project/src/com/xyz/utils/Bar.java</code> would be included,
	 * whereas <code>/Project/src/com/xyz/tests/T1.java</code>
	 * and <code>/Project/src/com/xyz/tests/quick/T2.java</code> would be
	 * excluded.
	 * </p>
	 * <p>
	 * Additionally, a source entry can be associated with a specific output location.
	 * By doing so, the Java builder will ensure that the generated ".class" files will
	 * be issued inside this output location, as opposed to be generated into the
	 * project default output location (when output location is <code>null</code>).
	 * Note that multiple source entries may target the same output location.
	 * The output location is referred to using an absolute path relative to the
	 * workspace root, e.g. <code>"/Project/bin"</code>, it must be located inside
	 * the same project as the source folder.
	 * </p>
	 * <p>
	 * Also note that all sources/binaries inside a project are contributed as
	 * a whole through a project entry
	 * (see <code>JavaCore.newProjectEntry</code>). Particular source entries
	 * cannot be selectively exported.
	 * </p>
	 * <p>
	 * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
	 * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
	 * Note that this list should not contain any duplicate name.
	 * </p>
	 *
	 * @param path the absolute workspace-relative path of a source folder
	 * @param inclusionPatterns the possibly empty list of inclusion patterns
	 *    represented as relative paths
	 * @param exclusionPatterns the possibly empty list of exclusion patterns
	 *    represented as relative paths
	 * @param specificOutputLocation the specific output location for this source entry (<code>null</code> if using project default ouput location)
	 * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
	 * @return a new source classpath entry with the given exclusion patterns
	 * @see IClasspathEntry#getInclusionPatterns()
	 * @see IClasspathEntry#getExclusionPatterns()
	 * @see IClasspathEntry#getOutputLocation()
	 * @since 3.1
	 */
	public static IClasspathEntry newSourceEntry(IPath path, IPath[] inclusionPatterns, IPath[] exclusionPatterns, IPath specificOutputLocation, IClasspathAttribute[] extraAttributes) {

		if (path == null) throw new ClasspathEntry.AssertionFailedException("Source path cannot be null"); //$NON-NLS-1$
		if (!path.isAbsolute()) throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
		if (exclusionPatterns == null) {
			exclusionPatterns = ClasspathEntry.EXCLUDE_NONE;
		}
		if (inclusionPatterns == null) {
			inclusionPatterns = ClasspathEntry.INCLUDE_ALL;
		}
		if (extraAttributes == null) {
			extraAttributes = ClasspathEntry.NO_EXTRA_ATTRIBUTES;
		}
		return new ClasspathEntry(
			IPackageFragmentRoot.K_SOURCE,
			IClasspathEntry.CPE_SOURCE,
			path,
			inclusionPatterns,
			exclusionPatterns,
			null, // source attachment
			null, // source attachment root
			specificOutputLocation, // custom output location
			false,
			null,
			false, // no access rules to combine
			extraAttributes);
	}

	
Creates and returns a new non-exported classpath entry of kind CPE_VARIABLE for the given path. This method is fully equivalent to calling 
newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], false). 
Params:
variablePath – the path of the binary archive; first segment is the
  name of a classpath variable
variableSourceAttachmentPath – the path of the corresponding source archive,
   or null if none; if present, the first segment is the
   name of a classpath variable (not necessarily the same variable
   as the one that begins variablePath)
sourceAttachmentRootPath – the location of the root of the source files within the source archive
   or null if variableSourceAttachmentPath is also null
Returns:
a new library classpath entry/**
	 * Creates and returns a new non-exported classpath entry of kind <code>CPE_VARIABLE</code>
	 * for the given path. This method is fully equivalent to calling
	 * {@link #newVariableEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
	 * newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], false)}.
	 *
	 * @param variablePath the path of the binary archive; first segment is the
	 *   name of a classpath variable
	 * @param variableSourceAttachmentPath the path of the corresponding source archive,
	 *    or <code>null</code> if none; if present, the first segment is the
	 *    name of a classpath variable (not necessarily the same variable
	 *    as the one that begins <code>variablePath</code>)
	 * @param sourceAttachmentRootPath the location of the root of the source files within the source archive
	 *    or <code>null</code> if <code>variableSourceAttachmentPath</code> is also <code>null</code>
	 * @return a new library classpath entry
	 */
	public static IClasspathEntry newVariableEntry(
		IPath variablePath,
		IPath variableSourceAttachmentPath,
		IPath sourceAttachmentRootPath) {

		return newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, false);
	}

	
Creates and returns a new classpath entry of kind CPE_VARIABLE for the given path. This method is fully equivalent to calling 
newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], isExported). 
Params:
variablePath – the path of the binary archive; first segment is the
  name of a classpath variable
variableSourceAttachmentPath – the path of the corresponding source archive,
   or null if none; if present, the first segment is the
   name of a classpath variable (not necessarily the same variable
   as the one that begins variablePath)
variableSourceAttachmentRootPath – the location of the root of the source files within the source archive
   or null if variableSourceAttachmentPath is also null
isExported – indicates whether this entry is contributed to dependent
	  projects in addition to the output location
Returns:
a new variable classpath entry
Since:
2.0/**
	 * Creates and returns a new classpath entry of kind <code>CPE_VARIABLE</code>
	 * for the given path. This method is fully equivalent to calling
	 * {@link #newVariableEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
	 * newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], isExported)}.
	 *
	 * @param variablePath the path of the binary archive; first segment is the
	 *   name of a classpath variable
	 * @param variableSourceAttachmentPath the path of the corresponding source archive,
	 *    or <code>null</code> if none; if present, the first segment is the
	 *    name of a classpath variable (not necessarily the same variable
	 *    as the one that begins <code>variablePath</code>)
	 * @param variableSourceAttachmentRootPath the location of the root of the source files within the source archive
	 *    or <code>null</code> if <code>variableSourceAttachmentPath</code> is also <code>null</code>
	 * @param isExported indicates whether this entry is contributed to dependent
	 * 	  projects in addition to the output location
	 * @return a new variable classpath entry
	 * @since 2.0
	 */
	public static IClasspathEntry newVariableEntry(
			IPath variablePath,
			IPath variableSourceAttachmentPath,
			IPath variableSourceAttachmentRootPath,
			boolean isExported) {

		return newVariableEntry(
			variablePath,
			variableSourceAttachmentPath,
			variableSourceAttachmentRootPath,
			ClasspathEntry.NO_ACCESS_RULES,
			ClasspathEntry.NO_EXTRA_ATTRIBUTES,
			isExported);
	}

	
Creates and returns a new classpath entry of kind CPE_VARIABLE
for the given path. The first segment of the path is the name of a classpath variable.
The trailing segments of the path will be appended to resolved variable path.

A variable entry allows to express indirect references on a classpath to other projects or libraries,
depending on what the classpath variable is referring.


It is possible to register an automatic initializer (ClasspathVariableInitializer),
which will be invoked through the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
After resolution, a classpath variable entry may either correspond to a project or a library entry.


e.g. Here are some examples of variable path usage


 "JDTCORE" where variable JDTCORE is
	bound to "c:/jars/jdtcore.jar". The resolved classpath entry is denoting the library "c:\jars\jdtcore.jar"
 "JDTCORE" where variable JDTCORE is
	bound to "/Project_JDTCORE". The resolved classpath entry is denoting the project "/Project_JDTCORE"
 "PLUGINS/com.example/example.jar" where variable PLUGINS
     is bound to "c:/eclipse/plugins". The resolved classpath entry is denoting the library "c:\eclipse\plugins\com.example\example.jar"

 The access rules determine the set of accessible class files in the project or library. If the list of access rules is empty then all files in this project or library are accessible. See IAccessRule for a detailed description of access rules. 

The extraAttributes list contains name/value pairs that must be persisted with
this entry. If no extra attributes are provided, an empty array must be passed in.

Note that this list should not contain any duplicate name.


The isExported flag indicates whether this entry is contributed to dependent
projects. If not exported, dependent projects will not see any of the classes from this entry.
If exported, dependent projects will concatenate the accessible files patterns of this entry with the
accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
with the non accessible files patterns of the project.


Note that this operation does not attempt to validate classpath variables
or access the resources at the given paths.

Params:
variablePath – the path of the binary archive; first segment is the
  name of a classpath variable
variableSourceAttachmentPath – the path of the corresponding source archive,
   or null if none; if present, the first segment is the
   name of a classpath variable (not necessarily the same variable
   as the one that begins variablePath)
variableSourceAttachmentRootPath – the location of the root of the source files within the source archive
   or null if variableSourceAttachmentPath is also null
accessRules – the possibly empty list of access rules for this entry
extraAttributes – the possibly empty list of extra attributes to persist with this entry
isExported – indicates whether this entry is contributed to dependent
	  projects in addition to the output location
Returns:
a new variable classpath entry
Since:
3.1/**
	 * Creates and returns a new classpath entry of kind <code>CPE_VARIABLE</code>
	 * for the given path. The first segment of the path is the name of a classpath variable.
	 * The trailing segments of the path will be appended to resolved variable path.
	 * <p>
	 * A variable entry allows to express indirect references on a classpath to other projects or libraries,
	 * depending on what the classpath variable is referring.
	 * </p>
	 * <p>
	 * It is possible to register an automatic initializer (<code>ClasspathVariableInitializer</code>),
	 * which will be invoked through the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
	 * After resolution, a classpath variable entry may either correspond to a project or a library entry.
	 * </p>
	 * <p>
	 * e.g. Here are some examples of variable path usage
	 * </p>
	 * <ul>
	 * <li> "JDTCORE" where variable <code>JDTCORE</code> is
	 *		bound to "c:/jars/jdtcore.jar". The resolved classpath entry is denoting the library "c:\jars\jdtcore.jar"</li>
	 * <li> "JDTCORE" where variable <code>JDTCORE</code> is
	 *		bound to "/Project_JDTCORE". The resolved classpath entry is denoting the project "/Project_JDTCORE"</li>
	 * <li> "PLUGINS/com.example/example.jar" where variable <code>PLUGINS</code>
	 *      is bound to "c:/eclipse/plugins". The resolved classpath entry is denoting the library "c:\eclipse\plugins\com.example\example.jar"</li>
	 * </ul>
	 * <p>
	 * The access rules determine the set of accessible class files
	 * in the project or library. If the list of access rules is empty then all files
	 * in this project or library are accessible.
	 * See {@link IAccessRule} for a detailed description of access rules.
	 * </p>
	 * <p>
	 * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
	 * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
	 * Note that this list should not contain any duplicate name.
	 * </p>
	 * <p>
	 * The <code>isExported</code> flag indicates whether this entry is contributed to dependent
	 * projects. If not exported, dependent projects will not see any of the classes from this entry.
	 * If exported, dependent projects will concatenate the accessible files patterns of this entry with the
	 * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
	 * with the non accessible files patterns of the project.
	 * </p>
	 * <p>
	 * Note that this operation does not attempt to validate classpath variables
	 * or access the resources at the given paths.
	 * </p>
	 *
	 * @param variablePath the path of the binary archive; first segment is the
	 *   name of a classpath variable
	 * @param variableSourceAttachmentPath the path of the corresponding source archive,
	 *    or <code>null</code> if none; if present, the first segment is the
	 *    name of a classpath variable (not necessarily the same variable
	 *    as the one that begins <code>variablePath</code>)
	 * @param variableSourceAttachmentRootPath the location of the root of the source files within the source archive
	 *    or <code>null</code> if <code>variableSourceAttachmentPath</code> is also <code>null</code>
	 * @param accessRules the possibly empty list of access rules for this entry
	 * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
	 * @param isExported indicates whether this entry is contributed to dependent
	 * 	  projects in addition to the output location
	 * @return a new variable classpath entry
	 * @since 3.1
	 */
	public static IClasspathEntry newVariableEntry(
			IPath variablePath,
			IPath variableSourceAttachmentPath,
			IPath variableSourceAttachmentRootPath,
			IAccessRule[] accessRules,
			IClasspathAttribute[] extraAttributes,
			boolean isExported) {

		if (variablePath == null) throw new ClasspathEntry.AssertionFailedException("Variable path cannot be null"); //$NON-NLS-1$
		if (variablePath.segmentCount() < 1) {
			throw new ClasspathEntry.AssertionFailedException("Illegal classpath variable path: \'" + variablePath.makeRelative().toString() + "\', must have at least one segment"); //$NON-NLS-1$//$NON-NLS-2$
		}
		if (accessRules == null || accessRules.length == 0) {
			accessRules = ClasspathEntry.NO_ACCESS_RULES;
		}
		if (extraAttributes == null || extraAttributes.length == 0) {
			extraAttributes = ClasspathEntry.NO_EXTRA_ATTRIBUTES;
		}

		return new ClasspathEntry(
			IPackageFragmentRoot.K_SOURCE,
			IClasspathEntry.CPE_VARIABLE,
			variablePath,
			ClasspathEntry.INCLUDE_ALL, // inclusion patterns
			ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
			variableSourceAttachmentPath, // source attachment
			variableSourceAttachmentRootPath, // source attachment root
			null, // specific output folder
			isExported,
			accessRules,
			false, // no access rules to combine
			extraAttributes);
	}
	
	
Returns an array of classpath entries that are referenced directly or indirectly by a given classpath entry. For the entry kind IClasspathEntry.CPE_LIBRARY, the method returns the libraries that are included in the Class-Path section of the MANIFEST.MF file. If a referenced JAR file has further references to other library entries, they are processed recursively and added to the list. For entry kinds other than IClasspathEntry.CPE_LIBRARY, this method returns an empty array. 
 
When a non-null project is passed, any additional attributes that may have been stored 
previously in the project's .classpath file are retrieved and populated in the 
corresponding referenced entry. If the project is null, the raw referenced entries are returned without any persisted attributes. For more details on storing referenced entries, see IJavaProject.setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath, IProgressMonitor). 
Params:
libraryEntry – the library entry whose referenced entries are sought
project – project where the persisted referenced entries to be retrieved from. If null
			persisted attributes are not attempted to be retrieved.
Returns:
an array of classpath entries that are referenced directly or indirectly by the given entry. 
			If not applicable, returns an empty array.
Since:
3.6/**
	 * Returns an array of classpath entries that are referenced directly or indirectly 
	 * by a given classpath entry. For the entry kind {@link IClasspathEntry#CPE_LIBRARY}, 
	 * the method returns the libraries that are included in the Class-Path section of 
	 * the MANIFEST.MF file. If a referenced JAR file has further references to other library 
	 * entries, they are processed recursively and added to the list. For entry kinds other 
	 * than {@link IClasspathEntry#CPE_LIBRARY}, this method returns an empty array.
	 * <p> 
	 * When a non-null project is passed, any additional attributes that may have been stored 
	 * previously in the project's .classpath file are retrieved and populated in the 
	 * corresponding referenced entry. If the project is <code>null</code>, the raw referenced
	 * entries are returned without any persisted attributes. 
	 * For more details on storing referenced entries, see 
	 * {@link IJavaProject#setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath, 
	 * IProgressMonitor)}. 
	 * </p>
	 * 
	 * @param libraryEntry the library entry whose referenced entries are sought 
	 * @param project project where the persisted referenced entries to be retrieved from. If <code>null</code>
	 * 			persisted attributes are not attempted to be retrieved.
	 * @return an array of classpath entries that are referenced directly or indirectly by the given entry. 
	 * 			If not applicable, returns an empty array.
	 * @since 3.6
	 */
	public static IClasspathEntry[] getReferencedClasspathEntries(IClasspathEntry libraryEntry, IJavaProject project) {
		JavaModelManager manager = JavaModelManager.getJavaModelManager();
		return manager.getReferencedClasspathEntries(libraryEntry, project);
	}

	
Removed the given classpath variable. Does nothing if no value was
set for this classpath variable.

This functionality cannot be used while the resource tree is locked.


Classpath variable values are persisted locally to the workspace, and
are preserved from session to session.

Params:
variableName – the name of the classpath variable
See Also:
setClasspathVariable(String, IPath)
Deprecated:
Use removeClasspathVariable(String, IProgressMonitor) instead/**
	 * Removed the given classpath variable. Does nothing if no value was
	 * set for this classpath variable.
	 * <p>
	 * This functionality cannot be used while the resource tree is locked.
	 * </p>
	 * <p>
	 * Classpath variable values are persisted locally to the workspace, and
	 * are preserved from session to session.
	 * </p>
	 *
	 * @param variableName the name of the classpath variable
	 * @see #setClasspathVariable(String, IPath)
	 *
	 * @deprecated Use {@link #removeClasspathVariable(String, IProgressMonitor)} instead
	 */
	public static void removeClasspathVariable(String variableName) {
		removeClasspathVariable(variableName, null);
	}

	
Removed the given classpath variable. Does nothing if no value was
set for this classpath variable.

This functionality cannot be used while the resource tree is locked.


Classpath variable values are persisted locally to the workspace, and
are preserved from session to session.

Params:
variableName – the name of the classpath variable
monitor – the progress monitor to report progress
See Also:
setClasspathVariable(String, IPath)/**
	 * Removed the given classpath variable. Does nothing if no value was
	 * set for this classpath variable.
	 * <p>
	 * This functionality cannot be used while the resource tree is locked.
	 * </p>
	 * <p>
	 * Classpath variable values are persisted locally to the workspace, and
	 * are preserved from session to session.
	 * </p>
	 *
	 * @param variableName the name of the classpath variable
	 * @param monitor the progress monitor to report progress
	 * @see #setClasspathVariable(String, IPath)
	 */
	public static void removeClasspathVariable(String variableName, IProgressMonitor monitor) {
		try {
			SetVariablesOperation operation = new SetVariablesOperation(new String[]{ variableName}, new IPath[]{ null }, true/*update preferences*/);
			operation.runOperation(monitor);
		} catch (JavaModelException e) {
			Util.log(e, "Exception while removing variable " + variableName); //$NON-NLS-1$
		}
	}

	
Removes the given element changed listener.
Has no effect if an identical listener is not registered.
Params:
listener – the listener/**
	 * Removes the given element changed listener.
	 * Has no effect if an identical listener is not registered.
	 *
	 * @param listener the listener
	 */
	public static void removeElementChangedListener(IElementChangedListener listener) {
		JavaModelManager.getDeltaState().removeElementChangedListener(listener);
	}

	
Removes the file extension from the given file name, if it has a Java-like file
extension. Otherwise the file name itself is returned.
Note this removes the dot ('.') before the extension as well.
Params:
fileName – the name of a file
Returns:
the fileName without the Java-like extension
Since:
3.2/**
	 * Removes the file extension from the given file name, if it has a Java-like file
	 * extension. Otherwise the file name itself is returned.
	 * Note this removes the dot ('.') before the extension as well.
	 *
	 * @param fileName the name of a file
	 * @return the fileName without the Java-like extension
	 * @since 3.2
	 */
	public static String removeJavaLikeExtension(String fileName) {
		return Util.getNameWithoutJavaLikeExtension(fileName);
	}

	
Removes the given pre-processing resource changed listener.

Has no effect if an identical listener is not registered.

Params:
listener – the listener
Since:
3.0/**
	 * Removes the given pre-processing resource changed listener.
	 * <p>
	 * Has no effect if an identical listener is not registered.
	 * </p>
	 *
	 * @param listener the listener
	 * @since 3.0
	 */
	public static void removePreProcessingResourceChangedListener(IResourceChangeListener listener) {
		JavaModelManager.getDeltaState().removePreResourceChangedListener(listener);
	}

	
Deletes the index, then rebuilds any portions of the index that are
currently needed by the workspace.
Params:
monitor – a progress monitor, or null if progress
   reporting and cancellation are not desired
Throws:
CoreException – 
Since:
3.13/**
	 * Deletes the index, then rebuilds any portions of the index that are
	 * currently needed by the workspace.
	 * 
	 * @param monitor a progress monitor, or <code>null</code> if progress
	 *    reporting and cancellation are not desired
	 * @throws CoreException 
	 * @since 3.13
	 */
	public static void rebuildIndex(IProgressMonitor monitor) throws CoreException {
		SubMonitor subMonitor = SubMonitor.convert(monitor, 100);
		IndexManager manager = JavaModelManager.getIndexManager();
		manager.deleteIndexFiles(subMonitor.split(1));
		manager.reset();
		// New index is disabled, see bug 544898.
		// However we keep this call here to cleanup the possibly existing database
		Indexer.getInstance().rebuildIndex(subMonitor.split(95));
		updateLegacyIndex(subMonitor.split(4));
	}

	
Runs the given action as an atomic Java model operation.

After running a method that modifies java elements,
registered listeners receive after-the-fact notification of
what just transpired, in the form of a element changed event.
This method allows clients to call a number of
methods that modify java elements and only have element
changed event notifications reported at the end of the entire
batch.


If this method is called outside the dynamic scope of another such
call, this method runs the action and then reports a single
element changed event describing the net effect of all changes
done to java elements by the action.


If this method is called in the dynamic scope of another such
call, this method simply runs the action.

Params:
action – the action to perform
monitor – a progress monitor, or null if progress
   reporting and cancellation are not desired
Throws:
CoreException – if the operation failed.
Since:
2.1/**
	 * Runs the given action as an atomic Java model operation.
	 * <p>
	 * After running a method that modifies java elements,
	 * registered listeners receive after-the-fact notification of
	 * what just transpired, in the form of a element changed event.
	 * This method allows clients to call a number of
	 * methods that modify java elements and only have element
	 * changed event notifications reported at the end of the entire
	 * batch.
	 * </p>
	 * <p>
	 * If this method is called outside the dynamic scope of another such
	 * call, this method runs the action and then reports a single
	 * element changed event describing the net effect of all changes
	 * done to java elements by the action.
	 * </p>
	 * <p>
	 * If this method is called in the dynamic scope of another such
	 * call, this method simply runs the action.
	 * </p>
	 *
	 * @param action the action to perform
	 * @param monitor a progress monitor, or <code>null</code> if progress
	 *    reporting and cancellation are not desired
	 * @exception CoreException if the operation failed.
	 * @since 2.1
	 */
	public static void run(IWorkspaceRunnable action, IProgressMonitor monitor) throws CoreException {
		run(action, ResourcesPlugin.getWorkspace().getRoot(), monitor);
	}
	
Runs the given action as an atomic Java model operation.

After running a method that modifies java elements,
registered listeners receive after-the-fact notification of
what just transpired, in the form of a element changed event.
This method allows clients to call a number of
methods that modify java elements and only have element
changed event notifications reported at the end of the entire
batch.


If this method is called outside the dynamic scope of another such
call, this method runs the action and then reports a single
element changed event describing the net effect of all changes
done to java elements by the action.


If this method is called in the dynamic scope of another such
call, this method simply runs the action.


The supplied scheduling rule is used to determine whether this operation can be
run simultaneously with workspace changes in other threads. See
IWorkspace.run(...) for more details.

Params:
action – the action to perform
rule – the scheduling rule to use when running this operation, or
null if there are no scheduling restrictions for this operation.
monitor – a progress monitor, or null if progress
   reporting and cancellation are not desired
Throws:
CoreException – if the operation failed.
Since:
3.0/**
	 * Runs the given action as an atomic Java model operation.
	 * <p>
	 * After running a method that modifies java elements,
	 * registered listeners receive after-the-fact notification of
	 * what just transpired, in the form of a element changed event.
	 * This method allows clients to call a number of
	 * methods that modify java elements and only have element
	 * changed event notifications reported at the end of the entire
	 * batch.
	 * </p>
	 * <p>
	 * If this method is called outside the dynamic scope of another such
	 * call, this method runs the action and then reports a single
	 * element changed event describing the net effect of all changes
	 * done to java elements by the action.
	 * </p>
	 * <p>
	 * If this method is called in the dynamic scope of another such
	 * call, this method simply runs the action.
	 * </p>
	 * <p>
 	 * The supplied scheduling rule is used to determine whether this operation can be
	 * run simultaneously with workspace changes in other threads. See
	 * <code>IWorkspace.run(...)</code> for more details.
 	 * </p>
	 *
	 * @param action the action to perform
	 * @param rule the scheduling rule to use when running this operation, or
	 * <code>null</code> if there are no scheduling restrictions for this operation.
	 * @param monitor a progress monitor, or <code>null</code> if progress
	 *    reporting and cancellation are not desired
	 * @exception CoreException if the operation failed.
	 * @since 3.0
	 */
	public static void run(IWorkspaceRunnable action, ISchedulingRule rule, IProgressMonitor monitor) throws CoreException {
		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		if (workspace.isTreeLocked()) {
			new BatchOperation(action).run(monitor);
		} else {
			// use IWorkspace.run(...) to ensure that a build will be done in autobuild mode
			workspace.run(new BatchOperation(action), rule, IWorkspace.AVOID_UPDATE, monitor);
		}
	}
	
Bind a container reference path to some actual containers (IClasspathContainer).
This API must be invoked whenever changes in container need to be reflected onto the JavaModel.
Containers can have distinct values in different projects, therefore this API considers a
set of projects with their respective containers.

containerPath is the path under which these values can be referenced through
container classpath entries (IClasspathEntry#CPE_CONTAINER). A container path
is formed by a first ID segment followed with extra segments, which can be used as additional hints
for the resolution. The container ID is used to identify a ClasspathContainerInitializer
registered on the extension point "org.eclipse.jdt.core.classpathContainerInitializer".


There is no assumption that each individual container value passed in argument
(respectiveContainers) must answer the exact same path when requested
IClasspathContainer#getPath.
Indeed, the containerPath is just an indication for resolving it to an actual container object. It can be
delegated to a ClasspathContainerInitializer, which can be activated through the extension
point "org.eclipse.jdt.core.ClasspathContainerInitializer").


In reaction to changing container values, the JavaModel will be updated to reflect the new
state of the updated container. A combined Java element delta will be notified to describe the corresponding
classpath changes resulting from the container update. This operation is batched, and automatically eliminates
unnecessary updates (new container is same as old one). This operation acquires a lock on the workspace's root.


This functionality cannot be used while the workspace is locked, since
it may create/remove some resource markers.


Classpath container values are persisted locally to the workspace, but
are not preserved from a session to another. It is thus highly recommended to register a
ClasspathContainerInitializer for each referenced container
(through the extension point "org.eclipse.jdt.core.ClasspathContainerInitializer").


Note: setting a container to null will cause it to be lazily resolved again whenever
its value is required. In particular, this will cause a registered initializer to be invoked
again.

Params:
containerPath – - the name of the container reference, which is being updated
affectedProjects – - the set of projects for which this container is being bound
respectiveContainers – - the set of respective containers for the affected projects
monitor – a monitor to report progress
Throws:
JavaModelException – 
See Also:
ClasspathContainerInitializer
getClasspathContainer(IPath, IJavaProject)
IClasspathContainer
Since:
2.0/**
	 * Bind a container reference path to some actual containers (<code>IClasspathContainer</code>).
	 * This API must be invoked whenever changes in container need to be reflected onto the JavaModel.
	 * Containers can have distinct values in different projects, therefore this API considers a
	 * set of projects with their respective containers.
	 * <p>
	 * <code>containerPath</code> is the path under which these values can be referenced through
	 * container classpath entries (<code>IClasspathEntry#CPE_CONTAINER</code>). A container path
	 * is formed by a first ID segment followed with extra segments, which can be used as additional hints
	 * for the resolution. The container ID is used to identify a <code>ClasspathContainerInitializer</code>
	 * registered on the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
	 * </p>
	 * <p>
	 * There is no assumption that each individual container value passed in argument
	 * (<code>respectiveContainers</code>) must answer the exact same path when requested
	 * <code>IClasspathContainer#getPath</code>.
	 * Indeed, the containerPath is just an indication for resolving it to an actual container object. It can be
	 * delegated to a <code>ClasspathContainerInitializer</code>, which can be activated through the extension
	 * point "org.eclipse.jdt.core.ClasspathContainerInitializer").
	 * </p>
	 * <p>
	 * In reaction to changing container values, the JavaModel will be updated to reflect the new
	 * state of the updated container. A combined Java element delta will be notified to describe the corresponding
	 * classpath changes resulting from the container update. This operation is batched, and automatically eliminates
	 * unnecessary updates (new container is same as old one). This operation acquires a lock on the workspace's root.
	 * </p>
	 * <p>
	 * This functionality cannot be used while the workspace is locked, since
	 * it may create/remove some resource markers.
	 * </p>
	 * <p>
	 * Classpath container values are persisted locally to the workspace, but
	 * are not preserved from a session to another. It is thus highly recommended to register a
	 * <code>ClasspathContainerInitializer</code> for each referenced container
	 * (through the extension point "org.eclipse.jdt.core.ClasspathContainerInitializer").
	 * </p>
	 * <p>
	 * Note: setting a container to <code>null</code> will cause it to be lazily resolved again whenever
	 * its value is required. In particular, this will cause a registered initializer to be invoked
	 * again.
	 * </p>
	 * @param containerPath - the name of the container reference, which is being updated
	 * @param affectedProjects - the set of projects for which this container is being bound
	 * @param respectiveContainers - the set of respective containers for the affected projects
	 * @param monitor a monitor to report progress
	 * @throws JavaModelException
	 * @see ClasspathContainerInitializer
	 * @see #getClasspathContainer(IPath, IJavaProject)
	 * @see IClasspathContainer
	 * @since 2.0
	 */
	public static void setClasspathContainer(IPath containerPath, IJavaProject[] affectedProjects, IClasspathContainer[] respectiveContainers, IProgressMonitor monitor) throws JavaModelException {
		if (affectedProjects.length != respectiveContainers.length)
			throw new ClasspathEntry.AssertionFailedException("Projects and containers collections should have the same size"); //$NON-NLS-1$
		if (affectedProjects.length == 1) {
			IClasspathContainer container = respectiveContainers[0];
			if (container != null) {
				JavaModelManager manager = JavaModelManager.getJavaModelManager();
				IJavaProject project = affectedProjects[0];
				IClasspathContainer existingCointainer = manager.containerGet(project, containerPath);
				if (existingCointainer == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) {
					manager.containerBeingInitializedPut(project, containerPath, container);
					return;
				}
			}
		}
		SetContainerOperation operation = new SetContainerOperation(containerPath, affectedProjects, respectiveContainers);
		operation.runOperation(monitor);
	}

	
Sets the value of the given classpath variable.
The path must have at least one segment.

This functionality cannot be used while the resource tree is locked.


Classpath variable values are persisted locally to the workspace, and
are preserved from session to session.

Params:
variableName – the name of the classpath variable
path – the path
Throws:
JavaModelException – 
See Also:
getClasspathVariable(String)
Deprecated:
Use setClasspathVariable(String, IPath, IProgressMonitor) instead/**
	 * Sets the value of the given classpath variable.
	 * The path must have at least one segment.
	 * <p>
	 * This functionality cannot be used while the resource tree is locked.
	 * </p>
	 * <p>
	 * Classpath variable values are persisted locally to the workspace, and
	 * are preserved from session to session.
	 * </p>
	 *
	 * @param variableName the name of the classpath variable
	 * @param path the path
	 * @throws JavaModelException
	 * @see #getClasspathVariable(String)
	 *
	 * @deprecated Use {@link #setClasspathVariable(String, IPath, IProgressMonitor)} instead
	 */
	public static void setClasspathVariable(String variableName, IPath path)
		throws JavaModelException {

		setClasspathVariable(variableName, path, null);
	}

	
Sets the value of the given classpath variable.
The path must not be null.
Since 3.5, the path to a library can also be relative to the project using ".." as the first segment. 

This functionality cannot be used while the resource tree is locked.


Classpath variable values are persisted locally to the workspace, and
are preserved from session to session.


Updating a variable with the same value has no effect.

Params:
variableName – the name of the classpath variable
path – the path
monitor – a monitor to report progress
Throws:
JavaModelException – 
See Also:
getClasspathVariable(String)/**
	 * Sets the value of the given classpath variable.
	 * The path must not be null.
	 * Since 3.5, the path to a library can also be relative to the project using ".." as the first segment. 
	 * <p>
	 * This functionality cannot be used while the resource tree is locked.
	 * </p>
	 * <p>
	 * Classpath variable values are persisted locally to the workspace, and
	 * are preserved from session to session.
	 * </p>
	 * <p>
	 * Updating a variable with the same value has no effect.
	 * </p>
	 *
	 * @param variableName the name of the classpath variable
	 * @param path the path
	 * @param monitor a monitor to report progress
	 * @throws JavaModelException
	 * @see #getClasspathVariable(String)
	 */
	public static void setClasspathVariable(
		String variableName,
		IPath path,
		IProgressMonitor monitor)
		throws JavaModelException {

		if (path == null) throw new ClasspathEntry.AssertionFailedException("Variable path cannot be null"); //$NON-NLS-1$
		setClasspathVariables(new String[]{variableName}, new IPath[]{ path }, monitor);
	}

	
Sets the values of all the given classpath variables at once.
Null paths can be used to request corresponding variable removal.
Since 3.5, the path to a library can also be relative to the project using ".." as the first segment.

A combined Java element delta will be notified to describe the corresponding
classpath changes resulting from the variables update. This operation is batched,
and automatically eliminates unnecessary updates (new variable is same as old one).
This operation acquires a lock on the workspace's root.


This functionality cannot be used while the workspace is locked, since
it may create/remove some resource markers.


Classpath variable values are persisted locally to the workspace, and
are preserved from session to session.


Updating a variable with the same value has no effect.

Params:
variableNames – an array of names for the updated classpath variables
paths – an array of path updates for the modified classpath variables (null
      meaning that the corresponding value will be removed
monitor – a monitor to report progress
Throws:
JavaModelException – 
See Also:
getClasspathVariable(String)
Since:
2.0/**
	 * Sets the values of all the given classpath variables at once.
	 * Null paths can be used to request corresponding variable removal.
	 * Since 3.5, the path to a library can also be relative to the project using ".." as the first segment.
	 * <p>
	 * A combined Java element delta will be notified to describe the corresponding
	 * classpath changes resulting from the variables update. This operation is batched,
	 * and automatically eliminates unnecessary updates (new variable is same as old one).
	 * This operation acquires a lock on the workspace's root.
	 * </p>
	 * <p>
	 * This functionality cannot be used while the workspace is locked, since
	 * it may create/remove some resource markers.
	 * </p>
	 * <p>
	 * Classpath variable values are persisted locally to the workspace, and
	 * are preserved from session to session.
	 * </p>
	 * <p>
	 * Updating a variable with the same value has no effect.
	 * </p>
	 *
	 * @param variableNames an array of names for the updated classpath variables
	 * @param paths an array of path updates for the modified classpath variables (null
	 *       meaning that the corresponding value will be removed
	 * @param monitor a monitor to report progress
	 * @throws JavaModelException
	 * @see #getClasspathVariable(String)
	 * @since 2.0
	 */
	public static void setClasspathVariables(
		String[] variableNames,
		IPath[] paths,
		IProgressMonitor monitor)
		throws JavaModelException {

		if (variableNames.length != paths.length)	throw new ClasspathEntry.AssertionFailedException("Variable names and paths collections should have the same size"); //$NON-NLS-1$
		SetVariablesOperation operation = new SetVariablesOperation(variableNames, paths, true/*update preferences*/);
		operation.runOperation(monitor);
	}

	
Sets the default compiler options inside the given options map according
to the given compliance.
The given compliance must be one of those supported by the compiler, that is one of the acceptable values for option COMPILER_COMPLIANCE.
The list of modified options is currently:

COMPILER_COMPLIANCE
COMPILER_SOURCE
COMPILER_CODEGEN_TARGET_PLATFORM
COMPILER_PB_ASSERT_IDENTIFIER
COMPILER_PB_ENUM_IDENTIFIER
COMPILER_CODEGEN_INLINE_JSR_BYTECODE for compliance levels 1.5 and greater
COMPILER_PB_ENABLE_PREVIEW_FEATURES for compliance levels 11 and greater
COMPILER_PB_REPORT_PREVIEW_FEATURES for compliance levels 11 and greater

If the given compliance is unknown, the given map is unmodified.
Params:
compliance – the given compliance
options – the given options map
Since:
3.3/**
	 * Sets the default compiler options inside the given options map according
	 * to the given compliance.
	 *
	 * <p>The given compliance must be one of those supported by the compiler,
	 * that is one of the acceptable values for option {@link #COMPILER_COMPLIANCE}.</p>
	 *
	 * <p>The list of modified options is currently:</p>
	 * <ul>
	 * <li>{@link #COMPILER_COMPLIANCE}</li>
	 * <li>{@link #COMPILER_SOURCE}</li>
	 * <li>{@link #COMPILER_CODEGEN_TARGET_PLATFORM}</li>
	 * <li>{@link #COMPILER_PB_ASSERT_IDENTIFIER}</li>
	 * <li>{@link #COMPILER_PB_ENUM_IDENTIFIER}</li>
	 * <li>{@link #COMPILER_CODEGEN_INLINE_JSR_BYTECODE} for compliance levels 1.5 and greater</li>
	 * <li>{@link #COMPILER_PB_ENABLE_PREVIEW_FEATURES} for compliance levels 11 and greater</li>
	 * <li>{@link #COMPILER_PB_REPORT_PREVIEW_FEATURES} for compliance levels 11 and greater</li>
	 * </ul>
	 *
	 * <p>If the given compliance is unknown, the given map is unmodified.</p>
	 *
	 * @param compliance the given {@link #COMPILER_COMPLIANCE compliance}
	 * @param options the given options map
	 * @since 3.3
	 */
	public static void setComplianceOptions(String compliance, Map options) {
		long jdkLevel = CompilerOptions.versionToJdkLevel(compliance);
		int major = (int) (jdkLevel >>> 16);
		switch(major) {
			case ClassFileConstants.MAJOR_VERSION_1_3:
				options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_3);
				options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_3);
				options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_1);
				options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.IGNORE);
				options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.IGNORE);
				break;
			case ClassFileConstants.MAJOR_VERSION_1_4:
				options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_4);
				options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_3);
				options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_2);
				options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.WARNING);
				options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.WARNING);
				break;
			case ClassFileConstants.MAJOR_VERSION_1_5:
				options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
				options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);
				options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_5);
				options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
				break;
			case ClassFileConstants.MAJOR_VERSION_1_6:
				options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_6);
				options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_6);
				options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_6);
				options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
				break;
			case ClassFileConstants.MAJOR_VERSION_1_7:
				options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_7);
				options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_7);
				options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_7);
				options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
				break;
			case ClassFileConstants.MAJOR_VERSION_1_8:
				options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_8);
				options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_8);
				options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_8);
				options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
				break;
			case ClassFileConstants.MAJOR_VERSION_9:
				options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_9);
				options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_9);
				options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_9);
				options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
				options.put(JavaCore.COMPILER_RELEASE, JavaCore.ENABLED);
				break;
			case ClassFileConstants.MAJOR_VERSION_10:
				options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_10);
				options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_10);
				options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_10);
				options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
				options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
				options.put(JavaCore.COMPILER_RELEASE, JavaCore.ENABLED);
				break;
			default:
				if(major > ClassFileConstants.MAJOR_VERSION_10) {
					String version = CompilerOptions.versionFromJdkLevel(jdkLevel);
					options.put(JavaCore.COMPILER_COMPLIANCE, version);
					options.put(JavaCore.COMPILER_SOURCE, version);
					options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, version);
					options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
					options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
					options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
					options.put(JavaCore.COMPILER_RELEASE, JavaCore.ENABLED);
					options.put(JavaCore.COMPILER_PB_ENABLE_PREVIEW_FEATURES, JavaCore.DISABLED);
					options.put(JavaCore.COMPILER_PB_REPORT_PREVIEW_FEATURES, JavaCore.WARNING);
				}
				break;
		}
	}

	
Sets the current table of options. All and only the options explicitly
included in the given table are remembered; all previous option settings
are forgotten, including ones not explicitly mentioned.

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.
Params:
newOptions – 
           the new options (key type: String; value type:
           String), or null to reset all
           options to their default values
See Also:
getDefaultOptions()
for changing default settings/**
	 * Sets the current table of options. All and only the options explicitly
	 * included in the given table are remembered; all previous option settings
	 * are forgotten, including ones not explicitly mentioned.
	 * <p>
	 * 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.
	 * </p>
	 * Note: each release may add new options.
	 *
	 * @param newOptions
	 *            the new options (key type: <code>String</code>; value type:
	 *            <code>String</code>), or <code>null</code> to reset all
	 *            options to their default values
	 * @see JavaCore#getDefaultOptions()
	 * @see JavaCorePreferenceInitializer for changing default settings
	 */
	public static void setOptions(Hashtable<String, String> newOptions) {
		JavaModelManager.getJavaModelManager().setOptions(newOptions);
	}

	
Returns the latest version of Java supported by the Java Model. This is usually the last entry from getAllVersions(). 
Since:
3.16
Returns:
the latest Java version support by Java Model/**
	 * Returns the latest version of Java supported by the Java Model. This is usually the last entry
	 * from {@link JavaCore#getAllVersions()}.
	 *
	 * @since 3.16
	 * @return the latest Java version support by Java Model
	 */
	public static String latestSupportedJavaVersion() {
		return allVersions.get(allVersions.size() - 1);
	}
	
Compares two given versions of the Java platform. The versions being compared must both be one of the supported values mentioned in COMPILER_CODEGEN_TARGET_PLATFORM, both values from COMPILER_COMPLIANCE, or both values from COMPILER_SOURCE. 
Params:
first – first version to be compared
second – second version to be compared
Returns:
the value 0 if both versions are the same; a value less than 0 if first is smaller than second; and a value greater than 0 if first is higher than second
Since:
3.12/**
	 * Compares two given versions of the Java platform. The versions being compared must both be
	 * one of the supported values mentioned in
	 * {@link #COMPILER_CODEGEN_TARGET_PLATFORM COMPILER_CODEGEN_TARGET_PLATFORM},
	 * both values from {@link #COMPILER_COMPLIANCE},  or both values from {@link #COMPILER_SOURCE}.
	 *
	 * @param first first version to be compared
	 * @param second second version to be compared
	 * @return the value {@code 0} if both versions are the same;
	 * 			a value less than {@code 0} if <code>first</code> is smaller than <code>second</code>; and
	 * 			a value greater than {@code 0} if <code>first</code> is higher than <code>second</code>
	 * @since 3.12
	 */
	public static int compareJavaVersions(String first, String second) {
		return Long.compare(CompilerOptions.versionToJdkLevel(first), CompilerOptions.versionToJdkLevel(second));
	}
	
Returns an array of module names referenced by this project indirectly. 
This is a helper method that can be used to construct a Java module 
description of an existing project. The referenced modules can either be 
system modules or user modules found in project build path in the form of 
libraries.
The prerequisites for this to be effective are:

the project is already in compliance level 9 or above.
the system library on the build path of the project is a modularized Java Runtime.

Params:
project – 
           the project whose referenced modules to be computed
Throws:
CoreException – 
Returns:
an array of String containing module names
Since:
3.14/**
	 * Returns an array of module names referenced by this project indirectly. 
	 * This is a helper method that can be used to construct a Java module 
	 * description of an existing project. The referenced modules can either be 
	 * system modules or user modules found in project build path in the form of 
	 * libraries.
	 * The prerequisites for this to be effective are:
	 * <ul>
	 * <li>the project is already in compliance level 9 or above.
	 * <li>the system library on the build path of the project is a modularized Java Runtime.
	 * </ul>
	 *
	 * @param project
	 *            the project whose referenced modules to be computed
	 * @return an array of String containing module names
	 * @throws CoreException
	 * @since 3.14
	 */
	public static String[] getReferencedModules(IJavaProject project) throws CoreException {
		return ModuleUtil.getReferencedModules(project);
	}

	
Returns the IModuleDescription that the given java element contains 
when regarded as an automatic module. The element must be an IPackageFragmentRoot
or an IJavaProject.
The returned module descriptor has a name (getElementName()) following
the specification of java.lang.module.ModuleFinder.of(Path...), but it
contains no other useful information.
Throws:
JavaModelException – 
IllegalArgumentException – if the provided element is neither IPackageFragmentRoot
	nor IJavaProject
Returns:
the IModuleDescription representing this java element as an automatic module,
		never null.
Since:
3.14/**
	 * Returns the <code>IModuleDescription</code> that the given java element contains 
	 * when regarded as an automatic module. The element must be an <code>IPackageFragmentRoot</code>
	 * or an <code>IJavaProject</code>.
	 * 
	 * <p>The returned module descriptor has a name (<code>getElementName()</code>) following
	 * the specification of <code>java.lang.module.ModuleFinder.of(Path...)</code>, but it
	 * contains no other useful information.</p>
	 * 
	 * @return the <code>IModuleDescription</code> representing this java element as an automatic module,
	 * 		never <code>null</code>.
	 * @throws JavaModelException
	 * @throws IllegalArgumentException if the provided element is neither <code>IPackageFragmentRoot</code>
	 * 	nor <code>IJavaProject</code>
	 * @since 3.14
	 */
	public static IModuleDescription getAutomaticModuleDescription(IJavaElement element) throws JavaModelException, IllegalArgumentException {
		switch (element.getElementType()) {
			case IJavaElement.JAVA_PROJECT:
				return ((JavaProject) element).getAutomaticModuleDescription();
			case IJavaElement.PACKAGE_FRAGMENT_ROOT:
				return ((PackageFragmentRoot) element).getAutomaticModuleDescription();
			default:
				throw new IllegalArgumentException("Illegal kind of java element: "+element.getElementType()); //$NON-NLS-1$
		}
	}

	
Filter the given set of system roots by the rules for root modules from JEP 261.
Params:
allSystemRoots – all physically available system modules, represented by their package fragment roots
Returns:
the list of names of default root modules
Since:
3.14/**
	 * Filter the given set of system roots by the rules for root modules from JEP 261.
	 * @param allSystemRoots all physically available system modules, represented by their package fragment roots
	 * @return the list of names of default root modules
	 * @since 3.14
	 */
	public static List<String> defaultRootModules(Iterable<IPackageFragmentRoot> allSystemRoots) {
		return JavaProject.defaultRootModules(allSystemRoots);
	}

	
Compile the given module description in the context of its enclosing Java project
and add class file attributes using the given map of attribute values.
In this map, the following keys are supported

IAttributeNamesConstants.MODULE_MAIN_CLASS
The associated value will be used for the ModuleMainClass attribute.
IAttributeNamesConstants.MODULE_PACKAGES
If the associated value is an empty string, then the compiler will generate a
ModulePackages attribute with a list of packages that is computed from

all exports directives
all opens directives
the implementation classes of all provides directives.

If the associated value is not empty, it must be a comma-separated list of package names,
which will be added to the computed list.

No other keys are supported in this version, but more keys may be added in the future.
Params:
module – handle for the module-info.java file to be compiled.
classFileAttributes – map of attribute names and values to be used during class file generation
Throws:
JavaModelException – 
IllegalArgumentException – if the map of classFileAttributes contains an unsupported key.
Returns:
the compiled byte code
Since:
3.14/**
	 * Compile the given module description in the context of its enclosing Java project
	 * and add class file attributes using the given map of attribute values.
	 * <p>In this map, the following keys are supported</p>
	 * <dl>
	 * <dt>{@link IAttributeNamesConstants#MODULE_MAIN_CLASS}</dt>
	 * <dd>The associated value will be used for the <code>ModuleMainClass</code> attribute.</dd>
	 * <dt>{@link IAttributeNamesConstants#MODULE_PACKAGES}</dt>
	 * <dd>If the associated value is an empty string, then the compiler will generate a
	 * <code>ModulePackages</code> attribute with a list of packages that is computed from
	 * <ul>
	 * <li>all <code>exports</code> directives
	 * <li>all <code>opens</code> directives
	 * <li>the implementation classes of all <code>provides</code> directives.
	 * </ul>
	 * If the associated value is not empty, it must be a comma-separated list of package names,
	 * which will be added to the computed list.
	 * </dl>
	 * <p>No other keys are supported in this version, but more keys may be added in the future.</p>
	 *
	 * @param module handle for the <code>module-info.java</code> file to be compiled.
	 * @param classFileAttributes map of attribute names and values to be used during class file generation
	 * @return the compiled byte code
	 * 
	 * @throws JavaModelException
	 * @throws IllegalArgumentException if the map of classFileAttributes contains an unsupported key.
	 * @since 3.14
	 */
	public static byte[] compileWithAttributes(IModuleDescription module, Map<String,String> classFileAttributes)
			throws JavaModelException, IllegalArgumentException
	{
		return new ModuleInfoBuilder().compileWithAttributes(module, classFileAttributes);
	}

	
Returns the module name computed for a jar. If the file is a jar and contains a module-info.class, the name
specified in it is used, otherwise, the algorithm for automatic module naming is used, which first looks for a
module name in the Manifest.MF and as last resort computes it from the file name.
Params:
file – the jar to examine
Returns:
null if file is not a file, otherwise the module name.
Since:
3.14/**
	 * Returns the module name computed for a jar. If the file is a jar and contains a module-info.class, the name
	 * specified in it is used, otherwise, the algorithm for automatic module naming is used, which first looks for a
	 * module name in the Manifest.MF and as last resort computes it from the file name.
	 * 
	 * @param file the jar to examine
	 * @return null if file is not a file, otherwise the module name.
	 * @since 3.14
	 */
	public static String getModuleNameFromJar(File file) {
		if (!file.isFile()) {
			return null;
		}

		char[] moduleName = null;
		try (ZipFile zipFile = new ZipFile(file)) {
			IModule module = null;
			ClassFileReader reader = ClassFileReader.read(zipFile, IModule.MODULE_INFO_CLASS);
			if (reader != null) {
				module = reader.getModuleDeclaration();
				if (module != null) {
					moduleName = module.name();
				}
			}
		} catch (ClassFormatException | IOException ex) {
			Util.log(ex);
		}
		if (moduleName == null) {
			moduleName = AutomaticModuleNaming.determineAutomaticModuleName(file.getAbsolutePath());
		}
		return new String(moduleName);
	}
	
	
Returns the names of the modules required by the module-info.class in the jar. If the file is not jar or a jar
that has no module-info.class is present, the empty set is returned.
Params:
file – the jar to examine
Returns:
set of module names.
Since:
3.14/**
	 * Returns the names of the modules required by the module-info.class in the jar. If the file is not jar or a jar
	 * that has no module-info.class is present, the empty set is returned.
	 * 
	 * @param file the jar to examine
	 * @return set of module names.
	 * @since 3.14
	 */
	public static Set<String> getRequiredModulesFromJar(File file) {
		if (!file.isFile()) {
			return Collections.emptySet();
		}
		try (ZipFile zipFile = new ZipFile(file)) {
			IModule module = null;
			ClassFileReader reader = ClassFileReader.read(zipFile, IModule.MODULE_INFO_CLASS);
			if (reader != null) {
				module = reader.getModuleDeclaration();
				if (module != null) {
					IModuleReference[] moduleRefs = module.requires();
					if (moduleRefs != null) {
						return Stream.of(moduleRefs).map(m -> new String(m.name()))
								.collect(Collectors.toCollection(LinkedHashSet::new));
					}
				}
			}
		} catch (ClassFormatException | IOException ex) {
			Util.log(ex);
		}
		return Collections.emptySet();
	}


	/* (non-Javadoc)
	 * Shutdown the JavaCore plug-in.
	 * <p>
	 * De-registers the JavaModelManager as a resource changed listener and save participant.
	 * </p>
	 * @see org.eclipse.core.runtime.Plugin#stop(BundleContext)
	 */
	@Override
	public void stop(BundleContext context) throws Exception {
		try {
			JavaModelManager.unregisterDebugOptionsListener();
			JavaModelManager.getJavaModelManager().shutdown();
		} finally {
			// ensure we call super.stop as the last thing
			super.stop(context);
		}
	}

	/* (non-Javadoc)
	 * Startup the JavaCore plug-in.
	 * <p>
	 * Registers the JavaModelManager as a resource changed listener and save participant.
	 * Starts the background indexing, and restore saved classpath variable values.
	 * </p>
	 * @throws Exception
	 * @see org.eclipse.core.runtime.Plugin#start(BundleContext)
	 */
	@Override
	public void start(BundleContext context) throws Exception {
		super.start(context);
		JavaModelManager.registerDebugOptionsListener(context);
		JavaModelManager.getJavaModelManager().startup();
		// New index is disabled, see bug 544898
		// Indexer.getInstance().rescanAll();
	}
}