Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2013 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation 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 /
 
 
 package org.eclipse.jdt.core;
 
 import java.util.Map;
 
 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.SubProgressMonitor;
 import  org.eclipse.core.runtime.jobs.ISchedulingRule;
 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.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.
 
 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").
 
 	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").
 
 	public static final String BUILDER_ID =  + ".javabuilder" ; //$NON-NLS-1$
 
The identifier for the Java model (value "org.eclipse.jdt.core.javamodel").
 
 	public static final String MODEL_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:
org.eclipse.core.resources.IProject.hasNature(java.lang.String)
 
 	public static final String NATURE_ID =  + ".javanature" ; //$NON-NLS-1$
 
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
 
 	public static final String USER_LIBRARY_CONTAINER_ID"org.eclipse.jdt.USER_LIBRARY"//$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
 
 	public static final String COMPILER_LOCAL_VARIABLE_ATTR =  + ".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
 
 	public static final String COMPILER_LINE_NUMBER_ATTR =  + ".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
 
 	public static final String COMPILER_SOURCE_FILE_ATTR =  + ".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
 
 	public static final String COMPILER_CODEGEN_UNUSED_LOCAL =  + ".compiler.codegen.unusedLocal"//$NON-NLS-1$
 	
Compiler option ID: Defining Target Java Platform.

For binary compatibility reason, .class files can be tagged to with certain VM versions and later.

Note that "1.4" target requires to toggle compliance mode to "1.4", "1.5" target requires to toggle compliance mode to "1.5", "1.6" target requires to toggle compliance mode to "1.6" and "1.7" target requires to toggle compliance mode to "1.7". "cldc1.1" requires the source version to be "1.3" and the compliance version to be "1.4" or lower.

Option id:
"org.eclipse.jdt.core.compiler.codegen.targetPlatform"
Possible values:
{ "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "cldc1.1" }
Default:
"1.2"

Category:
CompilerOptionID
 
 	public static final String COMPILER_CODEGEN_TARGET_PLATFORM =  + ".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
 
 	public static final String COMPILER_CODEGEN_INLINE_JSR_BYTECODE =  + ".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
 
 	public static final String COMPILER_DOC_COMMENT_SUPPORT =  + ".compiler.doc.comment.support"//$NON-NLS-1$
 	

Deprecated:
Discontinued since turning off would violate language specs.
Category:
DeprecatedOptionID
 
 	public static final String COMPILER_PB_UNREACHABLE_CODE =  + ".compiler.problem.unreachableCode"//$NON-NLS-1$
 	

Deprecated:
Discontinued since turning off would violate language specs.
Category:
DeprecatedOptionID
 
 	public static final String COMPILER_PB_INVALID_IMPORT =  + ".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", "ignore" }
Default:
"warning"

Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_OVERRIDING_PACKAGE_DEFAULT_METHOD =  + ".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", "ignore" }
Default:
"warning"

Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME =  + ".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", "ignore" }
Default:
"warning"

Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_DEPRECATION =  + ".compiler.problem.deprecation"//$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
 
 	public static final String COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE =  + ".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
 
 	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", "ignore" }
Default:
"warning"

Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_HIDDEN_CATCH_BLOCK =  + ".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", "ignore" }
Default:
"warning"

Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNUSED_LOCAL =  + ".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", "ignore" }
Default:
"ignore"

Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNUSED_PARAMETER =  + ".compiler.problem.unusedParameter"//$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
 
 	public static final String COMPILER_PB_UNUSED_PARAMETER_WHEN_IMPLEMENTING_ABSTRACT =  + ".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
 
 	public static final String COMPILER_PB_UNUSED_PARAMETER_WHEN_OVERRIDING_CONCRETE =  + ".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
 
 	public static final String COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE =  + ".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", "ignore" }
Default:
"warning"

Since:
2.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNUSED_IMPORT =  + ".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", "ignore" }
Default:
"warning"

Since:
3.4
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNUSED_TYPE_ARGUMENTS_FOR_METHOD_INVOCATION =  + ".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", "ignore" }
Default:
"ignore"

Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_SYNTHETIC_ACCESS_EMULATION =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.9
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNUSED_TYPE_PARAMETER =  + ".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", "ignore" }
Default:
"ignore"

Since:
2.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_NON_NLS_STRING_LITERAL =  + ".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", "ignore" }
Default:
"warning"

Since:
2.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_ASSERT_IDENTIFIER =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_ENUM_IDENTIFIER =  + ".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", "ignore" }
Default:
"warning"

Since:
2.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_STATIC_ACCESS_RECEIVER =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_INDIRECT_STATIC_ACCESS =  + ".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", "ignore" }
Default:
"warning"

Since:
2.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_NO_EFFECT_ASSIGNMENT =  + ".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", "ignore" }
Default:
"warning"

Since:
2.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_INCOMPATIBLE_NON_INHERITED_INTERFACE_METHOD =  + ".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", "ignore" }
Default:
"warning"

Since:
2.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNUSED_PRIVATE_MEMBER =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_LOCAL_VARIABLE_HIDING =  + ".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
 
 	public static final String COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_FIELD_HIDING =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_TYPE_PARAMETER_HIDING =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.2
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_FALLTHROUGH_CASE =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_EMPTY_STATEMENT =  + ".compiler.problem.emptyStatement"//$NON-NLS-1$
 	
Compiler option ID.
Option id:
"org.eclipse.jdt.core.compiler.problem.booleanMethodThrowingException"
Possible values:
{ "error", "warning", "ignore" }
Default:
"ignore"

Deprecated:
- this option has no effect
Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNNECESSARY_TYPE_CHECK =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNNECESSARY_ELSE =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNDOCUMENTED_EMPTY_BLOCK =  + ".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", "ignore" }
Default:
"warning"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_FINALLY_BLOCK_NOT_COMPLETING =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION =  + ".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
 
 	public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING =  + ".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
 
 	public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE =  + ".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 java.lang.Throwable or 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 java.lang.Throwable and java.lang.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
 
 	public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNQUALIFIED_FIELD_ACCESS =  + ".compiler.problem.unqualifiedFieldAccess"//$NON-NLS-1$
 	

Deprecated:
Use COMPILER_PB_UNCHECKED_TYPE_OPERATION instead.
Since:
3.1
Category:
DeprecatedOptionID
 
 	public static final String COMPILER_PB_UNSAFE_TYPE_OPERATION =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_UNCHECKED_TYPE_OPERATION =  + ".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", "ignore" }
Default:
"warning"

Since:
3.2
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_RAW_TYPE_REFERENCE =  + ".compiler.problem.rawTypeReference"//$NON-NLS-1$
 	
Compiler option ID: Reporting of Unavoidable Generic Type Problems.

When enabled, the compiler will issue an error or warning even when it detects a generic type problem that could not have been avoided by the programmer. 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
 
 	public static final String COMPILER_PB_UNAVOIDABLE_GENERIC_TYPE_PROBLEMS =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_FINAL_PARAMETER_BOUND =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_MISSING_SERIAL_VERSION =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_VARARGS_ARGUMENT_NEED_CAST =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.1
Category:
CompilerOptionID
 
 	public static final String COMPILER_PB_AUTOBOXING =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_ANNOTATION_SUPER_INTERFACE =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_MISSING_OVERRIDE_ANNOTATION =  + ".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
	public static final String COMPILER_PB_MISSING_OVERRIDE_ANNOTATION_FOR_INTERFACE_METHOD_IMPLEMENTATION =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_MISSING_DEPRECATED_ANNOTATION =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.5
Category:
CompilerOptionID
	public static final String COMPILER_PB_MISSING_HASHCODE_METHOD =  + ".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", "ignore" }
Default:
"warning"

Since:
3.5
Category:
CompilerOptionID
	public static final String COMPILER_PB_DEAD_CODE =  + ".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
	public static final String COMPILER_PB_DEAD_CODE_IN_TRIVIAL_IF_STATEMENT =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_INCOMPLETE_ENUM_SWITCH =  + ".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
	public static final String COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.8
Category:
CompilerOptionID
	public static final String COMPILER_PB_SWITCH_MISSING_DEFAULT_CASE =  + ".compiler.problem.missingDefaultCase"//$NON-NLS-1$

Deprecated:
Use COMPILER_PB_NULL_REFERENCE instead.
Since:
3.1
Category:
DeprecatedOptionID
	public static final String COMPILER_PB_INCONSISTENT_NULL_CHECK =  + ".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", "ignore" }
Default:
"warning"

Since:
3.2
Category:
CompilerOptionID
	public static final String COMPILER_PB_UNUSED_LABEL =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
	public static final String COMPILER_PB_INVALID_JAVADOC =  + ".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
	public static final String COMPILER_PB_INVALID_JAVADOC_TAGS =  + ".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
	public static final String COMPILER_PB_INVALID_JAVADOC_TAGS__DEPRECATED_REF =  + ".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
	public static final String COMPILER_PB_INVALID_JAVADOC_TAGS__NOT_VISIBLE_REF =  + ".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
	public static final String COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY =  + ".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
	public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
	public static final String COMPILER_PB_MISSING_JAVADOC_TAGS =  + ".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
	public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY =  + ".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
	public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING =  + ".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
	public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_METHOD_TYPE_PARAMETERS =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.0
Category:
CompilerOptionID
	public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS =  + ".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
	public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY =  + ".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
	public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING =  + ".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", "ignore" }
Default:
"warning"

Since:
2.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION =  + ".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
	public static final String COMPILER_PB_MAX_PER_UNIT =  + ".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
	public static final String COMPILER_PB_FATAL_OPTIONAL_ERROR =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.2
Category:
CompilerOptionID
	public static final String COMPILER_PB_PARAMETER_ASSIGNMENT =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.7
Category:
CompilerOptionID
	public static final String COMPILER_PB_MISSING_STATIC_ON_METHOD =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.7
Category:
CompilerOptionID
	public static final String COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD =  + ".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.reportUnclosedCloseable"
Possible values:
{ "error", "warning", "ignore" }
Default:
"warning"

Since:
3.8
Category:
CompilerOptionID
	public static final String COMPILER_PB_UNCLOSED_CLOSEABLE =  + ".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.reportPotentiallyUnclosedCloseable"
Possible values:
{ "error", "warning", "ignore" }
Default:
"ignore"

Since:
3.8
Category:
CompilerOptionID
	public static final String COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE =  + ".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.reportPotentiallyUnclosedCloseable"
Possible values:
{ "error", "warning", "ignore" }
Default:
"ignore"

Since:
3.8
Category:
CompilerOptionID
	public static final String COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE =  + ".compiler.problem.explicitlyClosedAutoCloseable"//$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
	public static final String COMPILER_ANNOTATION_NULL_ANALYSIS =  + ".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
	public static final String COMPILER_NULLABLE_ANNOTATION_NAME =  + ".compiler.annotation.nullable"//$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
	public static final String COMPILER_NONNULL_ANNOTATION_NAME =  + ".compiler.annotation.nonnull"//$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
	public static final String COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME =  + ".compiler.annotation.nonnullbydefault"//$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", "ignore" }.
Default:
"ignore"

Since:
3.8
Category:
CompilerOptionID
	public static final String COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION =  + ".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:

  1. A method declared with a nonnull annotation returns a nullable expression.
  2. 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.
  3. A nullable expression is assigned to a local variable that is declared with a nonnull annotation.
  4. 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).
  5. 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).
  6. A non-static field with a nonnull annotation is not definitely assigned at the end of each constructor.
  7. 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
	public static final String COMPILER_PB_NULL_SPECIFICATION_VIOLATION =  + ".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:

  1. A method declared with a nonnull annotation returns an expression that is statically known to evaluate to a null value on some flow.
  2. 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.
  3. 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", "ignore" }
Default:
"error"

Since:
3.8
Category:
CompilerOptionID
	public static final String COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT =  + ".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:

  1. 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.
  2. 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.
  3. 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", "ignore" }
Default:
"warning"

Since:
3.8
Category:
CompilerOptionID
	public static final String COMPILER_PB_NULL_UNCHECKED_CONVERSION =  + ".compiler.problem.nullUncheckedConversion"//$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", "ignore" }
Default:
"warning"

Since:
3.8
Category:
CompilerOptionID
	public static final String COMPILER_PB_REDUNDANT_NULL_ANNOTATION =  + ".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
	public static final String COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS = .+".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
	public static final String COMPILER_INHERIT_NULL_ANNOTATIONS = .+".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", "ignore" }
Default:
"warning"

Since:
3.9
Category:
CompilerOptionID
	public static final String COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED = .+".compiler.problem.nonnullParameterAnnotationDropped"//$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. Once toggled, the target VM level should be set to "1.5" and the compliance mode should be "1.5".

Source level 1.6 is necessary to enable the computation of stack map tables. Once toggled, the target VM level should be set to "1.6" and the compliance mode should be "1.6".

Once the source level 1.7 is toggled, the target VM level should be set to "1.7" and the compliance mode should be "1.7".

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

Since:
2.0
Category:
CompilerOptionID
	public static final String COMPILER_SOURCE =  + ".compiler.source"//$NON-NLS-1$
Compiler option ID: Setting Compliance Level.

Select the compliance level for the compiler. In "1.3" mode, source and target settings should not go beyond "1.3" level.

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

Since:
2.0
Category:
CompilerOptionID
	public static final String COMPILER_COMPLIANCE =  + ".compiler.compliance"//$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"

Since:
2.1
See also:
COMPILER_TASK_TAGS
Category:
CompilerOptionID
	public static final String COMPILER_TASK_PRIORITIES =  + ".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"

Since:
2.1
See also:
COMPILER_TASK_PRIORITIES
Category:
CompilerOptionID
	public static final String COMPILER_TASK_TAGS =  + ".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
	public static final String COMPILER_TASK_CASE_SENSITIVE =  + ".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", "ignore" }
Default:
"error"

Since:
3.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_FORBIDDEN_REFERENCE =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_DISCOURAGED_REFERENCE =  + ".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
	public static final String COMPILER_PB_SUPPRESS_WARNINGS =  + ".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
	public static final String COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS =  + ".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
	public static final String COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS =  + ".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", "ignore" }
Default:
"warning"

Since:
3.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_UNHANDLED_WARNING_TOKEN =  + ".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", "ignore" }
Default:
"warning"

Since:
3.4
Category:
CompilerOptionID
	public static final String COMPILER_PB_UNUSED_WARNING_TOKEN =  + ".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", "ignore" }
Default:
"warning"

Since:
3.2
Category:
CompilerOptionID
	public static final String COMPILER_PB_NULL_REFERENCE =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.3
Category:
CompilerOptionID
	public static final String COMPILER_PB_POTENTIAL_NULL_REFERENCE =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.3
Category:
CompilerOptionID
	public static final String COMPILER_PB_REDUNDANT_NULL_CHECK =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.3
Category:
CompilerOptionID
	public static final String COMPILER_PB_OVERRIDING_METHOD_WITHOUT_SUPER_INVOCATION =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.4
Category:
CompilerOptionID
	public static final String COMPILER_PB_REDUNDANT_SUPERINTERFACE =  + ".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", "ignore" }
Default:
"warning"

Since:
3.5
Category:
CompilerOptionID
	public static final String COMPILER_PB_COMPARING_IDENTICAL =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.5
Category:
CompilerOptionID
	public static final String COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.6
Category:
CompilerOptionID
	public static final String COMPILER_PB_UNUSED_OBJECT_ALLOCATION =  + ".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", "ignore" }
Default:
"ignore"

Since:
3.7.1
Category:
CompilerOptionID
	public static final String COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS =  + ".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
	public static final String CORE_JAVA_BUILD_ORDER =  + ".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
	public static final String CORE_JAVA_BUILD_RESOURCE_COPY_FILTER =  + ".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
	public static final String CORE_JAVA_BUILD_DUPLICATE_RESOURCE =  + ".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
	public static final String CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER =  + ".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
	public static final String CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER =  + ".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
	public static final String CORE_INCOMPLETE_CLASSPATH =  + ".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
	public static final String CORE_CIRCULAR_CLASSPATH =  + ".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
	public static final String CORE_INCOMPATIBLE_JDK_LEVEL =  + ".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
	public static final String CORE_JAVA_BUILD_INVALID_CLASSPATH =  + ".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
	public static final String CORE_ENCODING =  + ".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
	public static final String CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS =  + ".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
	public static final String CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS =  + ".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
	public static final String CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE =  + ".classpath.outputOverlappingAnotherSource";  //$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
	public static final String TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC =  + ".timeoutForParameterNameFromAttachedJavadoc"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION, org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_BLOCK , org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION, org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION, org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_SWITCH, org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION instead.
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_NEWLINE_OPENING_BRACE =  + ".formatter.newline.openingBrace"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT, org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT, org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT, org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT instead.
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_NEWLINE_CONTROL =  + ".formatter.newline.controlStatement"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_COMPACT_ELSE_IF instead.
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_NEWLINE_ELSE_IF =  + ".formatter.newline.elseIf"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK instead.
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_NEWLINE_EMPTY_BLOCK =  + ".formatter.newline.emptyBlock"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE instead.
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_CLEAR_BLANK_LINES =  + ".formatter.newline.clearAll"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_LINE_SPLIT instead
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_LINE_SPLIT =  + ".formatter.lineSplit"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR instead.
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_COMPACT_ASSIGNMENT =  + ".formatter.style.assignment"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR instead.
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_TAB_CHAR =  + ".formatter.tabulation.char"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE instead.
Since:
2.0
Category:
DeprecatedOptionID
	public static final String FORMATTER_TAB_SIZE =  + ".formatter.tabulation.size"//$NON-NLS-1$

Deprecated:
Use org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants.FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST instead.
Since:
2.1
Category:
DeprecatedOptionID
	public static final String FORMATTER_SPACE_CASTEXPRESSION =  + ".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
	public static final String CODEASSIST_VISIBILITY_CHECK =  + ".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
	public static final String CODEASSIST_DEPRECATION_CHECK =  + ".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
	public static final String CODEASSIST_CAMEL_CASE_MATCH =  + ".codeComplete.camelCaseMatch"//$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
	public static final String CODEASSIST_IMPLICIT_QUALIFICATION =  + ".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
	public static final String CODEASSIST_FIELD_PREFIXES =  + ".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
	public static final String CODEASSIST_STATIC_FIELD_PREFIXES =  + ".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
	public static final String CODEASSIST_STATIC_FINAL_FIELD_PREFIXES =  + ".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
	public static final String CODEASSIST_LOCAL_PREFIXES =  + ".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
	public static final String CODEASSIST_ARGUMENT_PREFIXES =  + ".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
	public static final String CODEASSIST_FIELD_SUFFIXES =  + ".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
	public static final String CODEASSIST_STATIC_FIELD_SUFFIXES =  + ".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
	public static final String CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES =  + ".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
	public static final String CODEASSIST_LOCAL_SUFFIXES =  + ".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
	public static final String CODEASSIST_ARGUMENT_SUFFIXES =  + ".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
	public static final String CODEASSIST_FORBIDDEN_REFERENCE_CHECK + ".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
	public static final String CODEASSIST_DISCOURAGED_REFERENCE_CHECK + ".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
	public static final String CODEASSIST_SUGGEST_STATIC_IMPORTS + ".codeComplete.suggestStaticImports"//$NON-NLS-1$
	// end configurable option IDs }
	// Begin configurable option values {

Deprecated:
Use 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
	public static final String DEFAULT_TASK_PRIORITY = "NORMAL"//$NON-NLS-1$
Configurable option value: .

Since:
3.0
Category:
OptionValue
	public static final String DEFAULT_TASK_TAGS = "TODO,FIXME,XXX"//$NON-NLS-1$
Configurable option value: .

Since:
3.0
Category:
OptionValue
	public static final String DEFAULT_TASK_PRIORITIES = "NORMAL,HIGH,NORMAL"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String GENERATE = "generate"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String DO_NOT_GENERATE = "do not generate"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String PRESERVE = "preserve"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String OPTIMIZE_OUT = "optimize out"//$NON-NLS-1$
Configurable option value for COMPILER_TASK_PRIORITIES: .

Since:
2.1
Category:
OptionValue
	public static final String COMPILER_TASK_PRIORITY_HIGH = "HIGH"//$NON-NLS-1$
Configurable option value for COMPILER_TASK_PRIORITIES: .

Since:
2.1
Category:
OptionValue
	public static final String COMPILER_TASK_PRIORITY_LOW = "LOW"//$NON-NLS-1$
Configurable option value for COMPILER_TASK_PRIORITIES: .

Since:
2.1
Category:
OptionValue
	public static final String COMPILER_TASK_PRIORITY_NORMAL = "NORMAL"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String VERSION_1_1 = "1.1"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String VERSION_1_2 = "1.2"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String VERSION_1_3 = "1.3"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String VERSION_1_4 = "1.4"//$NON-NLS-1$
Configurable option value: .

Since:
3.0
Category:
OptionValue
	public static final String VERSION_1_5 = "1.5"//$NON-NLS-1$
Configurable option value: .

Since:
3.2
Category:
OptionValue
	public static final String VERSION_1_6 = "1.6"//$NON-NLS-1$
Configurable option value: .

Since:
3.3
Category:
OptionValue
	public static final String VERSION_1_7 = "1.7"//$NON-NLS-1$
Configurable option value: .

Since:
3.4
Category:
OptionValue
	public static final String VERSION_CLDC_1_1 = "cldc1.1"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String ABORT = "abort"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String ERROR = "error"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String WARNING = "warning"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String IGNORE = "ignore"//$NON-NLS-1$
Configurable option value: .

Category:
OptionValue
	public static final String COMPUTE = "compute"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String INSERT = "insert"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String DO_NOT_INSERT = "do not insert"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String PRESERVE_ONE = "preserve one"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String CLEAR_ALL = "clear all"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String NORMAL = "normal"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String COMPACT = "compact"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String TAB = "tab"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String SPACE = "space"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String ENABLED = "enabled"//$NON-NLS-1$
Configurable option value: .

Since:
2.0
Category:
OptionValue
	public static final String DISABLED = "disabled"//$NON-NLS-1$
Configurable option value: .

Since:
2.1
Category:
OptionValue
	public static final String CLEAN = "clean"//$NON-NLS-1$
Configurable option value: .

Since:
3.0
Category:
OptionValue
	public static final String PUBLIC = "public"//$NON-NLS-1$
Configurable option value: .

Since:
3.0
Category:
OptionValue
	public static final String PROTECTED = "protected"//$NON-NLS-1$
Configurable option value: .

Since:
3.0
Category:
OptionValue
	public static final String DEFAULT = "default"//$NON-NLS-1$
Configurable option value: .

Since:
3.0
Category:
OptionValue
	public static final String PRIVATE = "private"//$NON-NLS-1$
Configurable option value: .

Since:
3.1
Category:
OptionValue
	public static final String NEVER = "never"//$NON-NLS-1$
Configurable option value: .

Since:
3.4
Category:
OptionValue
Configurable option value: .

Since:
3.4
Category:
OptionValue
Configurable option value: .

Since:
3.4
Category:
OptionValue
	// 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.

Since:
3.2
See also:
org.eclipse.core.runtime.content.IContentTypeManager.getContentType(String)
getJavaLikeExtensions()
	public static final String JAVA_SOURCE_CONTENT_TYPE = .+".javaSource" ; //$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
	public JavaCore() {
		super();
	}

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.

Parameters:
listener the listener
See also:
ElementChangedEvent
	public static void addElementChangedListener(IElementChangedListener listener) {
	}

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.

Parameters:
listener the listener
eventMask the bit-wise OR of all event types of interest to the listener
Since:
2.0
See also:
IElementChangedListener
ElementChangedEvent
removeElementChangedListener(IElementChangedListener)
	public static void addElementChangedListener(IElementChangedListener listenerint eventMask) {
		JavaModelManager.getDeltaState().addElementChangedListener(listenereventMask);
	}

Configures the given marker attribute map for the given Java element. Used for markers, which denote a Java element rather than a resource.

Parameters:
attributes the mutable marker attribute map (key type: String, value type: String)
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 = ((IMemberelement).getClassFile();
		if (attributes != null && element != null)
			attributes.put(element.getHandleIdentifier());
	private static void addNonJavaResources(Object[] nonJavaResources,
			IContainer container,
			int rootPathSegmentCounts,
			ArrayList collector) {
		for (int i = 0, max = nonJavaResources.lengthi < maxi++) {
			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(memberscontainerrootPathSegmentCountscollector);
	}

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.

Deprecated:
use addPreProcessingResourceChangedListener(listener, IResourceChangeEvent.POST_CHANGE) instead
Parameters:
listener the listener
Since:
3.0
See also:
removePreProcessingResourceChangedListener(IResourceChangeListener)
	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.

Parameters:
listener the listener
eventMask the bit-wise OR of all event types of interest to the listener
Since:
3.2
See also:
removePreProcessingResourceChangedListener(IResourceChangeListener)
IResourceChangeEvent
	public static void addPreProcessingResourceChangedListener(IResourceChangeListener listenerint eventMask) {
		JavaModelManager.getDeltaState().addPreResourceChangedListener(listenereventMask);
	}

Configures the given marker for the given Java element. Used for markers, which denote a Java element rather than a resource.

Parameters:
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
	public void configureJavaElementMarker(IMarker markerIJavaElement element)
		throws CoreException {
		if (element instanceof IMember)
			element = ((IMemberelement).getClassFile();
		if (marker != null && element != null)
			marker.setAttribute(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.

Parameters:
handleIdentifier the given handle identifier
Returns:
the Java element corresponding to the handle identifier
	public static IJavaElement create(String handleIdentifier) {
		return create(handleIdentifier.);
	}

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.

Parameters:
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
	public static IJavaElement create(String handleIdentifierWorkingCopyOwner owner) {
		if (handleIdentifier == null) {
			return null;
		if (owner == null)
		MementoTokenizer memento = new MementoTokenizer(handleIdentifier);
		JavaModel model = JavaModelManager.getJavaModelManager().getJavaModel();
		return model.getHandleFromMemento(mementoowner);
	}

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.

Parameters:
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
	public static IJavaElement create(IFile file) {
		return JavaModelManager.create(filenull/*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.

Parameters:
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
	public static IJavaElement create(IFolder folder) {
		return JavaModelManager.create(foldernull/*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.

Parameters:
project the given project
Returns:
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.

Parameters:
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
	public static IJavaElement create(IResource resource) {
		return JavaModelManager.create(resourcenull/*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.

Parameters:
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
	public static IJavaElement create(IResource resourceIJavaProject project) {
		return JavaModelManager.create(resourceproject);
	}
Returns the Java model.

Parameters:
root the given root
Returns:
the Java model, or null 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.

Parameters:
file the given .class file
Returns:
a class file element for the given .class file, or null if unable to recognize the class file
	public static IClassFile createClassFileFrom(IFile file) {
		return JavaModelManager.createClassFileFrom(filenull);
	}
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.

Parameters:
file the given source file
Returns:
a compilation unit element for the given source file, or null if unable to recognize the compilation unit
	public static ICompilationUnit createCompilationUnitFrom(IFile file) {
		return JavaModelManager.createCompilationUnitFrom(filenull/*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.

Parameters:
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)
		return JavaModelManager.createJarPackageFragmentRootFrom(filenull/*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").

Parameters:
containerPath the name of the container, which needs to be resolved
project a specific project in which the container is being resolved
Returns:
the corresponding classpath container or null if unable to find one.
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).
Since:
2.0
See also:
ClasspathContainerInitializer
IClasspathContainer
setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
	public static IClasspathContainer getClasspathContainer(IPath containerPathIJavaProject projectthrows JavaModelException {
	    JavaModelManager manager = JavaModelManager.getJavaModelManager();
		IClasspathContainer container = manager.getClasspathContainer(containerPathproject);
		    return manager.getPreviousSessionContainer(containerPathproject);
		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.

Parameters:
containerID - a containerID identifying a registered initializer
Returns:
ClasspathContainerInitializer - the registered classpath container initializer or null if none was found.
Since:
2.1
		Hashtable containerInitializersCache = JavaModelManager.getJavaModelManager().;
		ClasspathContainerInitializer initializer = (ClasspathContainerInitializercontainerInitializersCache.get(containerID);
		if (initializer == null) {
			initializer = computeClasspathContainerInitializer(containerID);
			if (initializer == null)
				return null;
			containerInitializersCache.put(containerIDinitializer);
		return initializer;
		Plugin jdtCorePlugin = JavaCore.getPlugin();
		if (jdtCorePlugin == nullreturn null;
		IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(..);
		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)){
							verbose_found_container_initializer(containerIDconfigurationElement);
						try {