/*******************************************************************************
* Copyright (c) 2000, 2010 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
*******************************************************************************/
package org.eclipse.jdt.core;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Map;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.core.search.TypeNameRequestor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.core.BatchOperation;
import org.eclipse.jdt.internal.core.BufferFactoryWrapper;
import org.eclipse.jdt.internal.core.BufferManager;
import org.eclipse.jdt.internal.core.ClasspathAccessRule;
import org.eclipse.jdt.internal.core.ClasspathAttribute;
import org.eclipse.jdt.internal.core.ClasspathEntry;
import org.eclipse.jdt.internal.core.CreateTypeHierarchyOperation;
import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
import org.eclipse.jdt.internal.core.ExternalFoldersManager;
import org.eclipse.jdt.internal.core.JavaCorePreferenceInitializer;
import org.eclipse.jdt.internal.core.JavaModel;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.core.Region;
import org.eclipse.jdt.internal.core.SetContainerOperation;
import org.eclipse.jdt.internal.core.SetVariablesOperation;
import org.eclipse.jdt.internal.core.builder.JavaBuilder;
import org.eclipse.jdt.internal.core.builder.State;
import org.eclipse.jdt.internal.core.util.MementoTokenizer;
import org.eclipse.jdt.internal.core.util.Messages;
import org.eclipse.jdt.internal.core.util.Util;
import org.osgi.framework.BundleContext;
/**
* The plug-in runtime class for the Java model plug-in containing the core (UI-free) support for
* Java projects.
* <p>
* Like all plug-in runtime classes (subclasses of <code>Plugin</code>), this class is automatically
* instantiated by the platform when the plug-in gets activated. Clients must not attempt to
* instantiate plug-in runtime classes directly.
* </p>
* <p>
* The single instance of this class can be accessed from any plug-in declaring the Java model
* plug-in as a prerequisite via <code>JavaCore.getJavaCore()</code>. The Java model plug-in will be
* activated automatically if not already active.
* </p>
*
* @noinstantiate This class is not intended to be instantiated by clients.
*/
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 <code>"org.eclipse.jdt.core"</code>).
*/
public static final String PLUGIN_ID= "org.eclipse.jdt.core"; //$NON-NLS-1$
/**
* The identifier for the Java builder (value <code>"org.eclipse.jdt.core.javabuilder"</code>).
*/
public static final String BUILDER_ID= PLUGIN_ID + ".javabuilder"; //$NON-NLS-1$
/**
* The identifier for the Java model (value <code>"org.eclipse.jdt.core.javamodel"</code>).
*/
public static final String MODEL_ID= PLUGIN_ID + ".javamodel"; //$NON-NLS-1$
/**
* The identifier for the Java nature (value <code>"org.eclipse.jdt.core.javanature"</code>).
* The presence of this nature on a project indicates that it is Java-capable.
*
* @see org.eclipse.core.resources.IProject#hasNature(java.lang.String)
*/
public static final String NATURE_ID= PLUGIN_ID + ".javanature"; //$NON-NLS-1$
/**
* Name of the handle id attribute in a Java marker.
*/
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.
* <p>
* When generated, this attribute will enable local variable names to be displayed in debugger,
* only in place where variables are definitely assigned (.class file is then bigger).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.debug.localVariable"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "generate", "do not generate" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"generate"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_LOCAL_VARIABLE_ATTR= PLUGIN_ID + ".compiler.debug.localVariable"; //$NON-NLS-1$
/**
* Compiler option ID: Generating Line Number Debug Attribute.
* <p>
* When generated, this attribute will enable source code highlighting in debugger (.class file
* is then bigger).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.debug.lineNumber"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "generate", "do not generate" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"generate"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_LINE_NUMBER_ATTR= PLUGIN_ID + ".compiler.debug.lineNumber"; //$NON-NLS-1$
/**
* Compiler option ID: Generating Source Debug Attribute.
* <p>
* When generated, this attribute will enable the debugger to present the corresponding source
* code.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.debug.sourceFile"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "generate", "do not generate" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"generate"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_SOURCE_FILE_ATTR= PLUGIN_ID + ".compiler.debug.sourceFile"; //$NON-NLS-1$
/**
* Compiler option ID: Preserving Unused Local Variables.
* <p>
* Unless requested to preserve unused local variables (that is, never read), the compiler will
* optimize them out, potentially altering debugging.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.codegen.unusedLocal"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "preserve", "optimize out" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"preserve"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_CODEGEN_UNUSED_LOCAL= PLUGIN_ID + ".compiler.codegen.unusedLocal"; //$NON-NLS-1$
/**
* Compiler option ID: Defining Target Java Platform.
* <p>
* For binary compatibility reason, .class files can be tagged to with certain VM versions and
* later.
* <p>
* Note that <code>"1.4"</code> target requires to toggle compliance mode to <code>"1.4"</code>,
* <code>"1.5"</code> target requires to toggle compliance mode to <code>"1.5"</code>,
* <code>"1.6"</code> target requires to toggle compliance mode to <code>"1.6"</code> and
* <code>"1.7"</code> target requires to toggle compliance mode to <code>"1.7"</code>.
* <code>"cldc1.1"</code> requires the source version to be <code>"1.3"</code> and the
* compliance version to be <code>"1.4"</code> or lower.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.codegen.targetPlatform"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "cldc1.1" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"1.2"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_CODEGEN_TARGET_PLATFORM= PLUGIN_ID + ".compiler.codegen.targetPlatform"; //$NON-NLS-1$
/**
* Compiler option ID: Inline JSR Bytecode Instruction.
* <p>
* When enabled, the compiler will no longer generate JSR instructions, but rather inline
* corresponding subroutine code sequences (mostly corresponding to try finally blocks). The
* generated code will thus get bigger, but will load faster on virtual machines since the
* verification process is then much simpler.
* <p>
* This mode is anticipating support for the Java Specification Request 202.
* <p>
* Note that JSR inlining is optional only for target platform lesser than 1.5. From 1.5 on, the
* JSR inlining is mandatory (also see related setting {@link #COMPILER_CODEGEN_TARGET_PLATFORM}
* ).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_CODEGEN_INLINE_JSR_BYTECODE= PLUGIN_ID + ".compiler.codegen.inlineJsrBytecode"; //$NON-NLS-1$
/**
* Compiler option ID: Javadoc Comment Support.
* <p>
* When this support is disabled, the compiler will ignore all javadoc problems options settings
* and will not report any javadoc problem. It will also not find any reference in javadoc
* comment and DOM AST Javadoc node will be only a flat text instead of having structured tag
* elements.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.doc.comment.support"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_DOC_COMMENT_SUPPORT= PLUGIN_ID + ".compiler.doc.comment.support"; //$NON-NLS-1$
/**
* @deprecated Discontinued since turning off would violate language specs.
* @category DeprecatedOptionID
*/
public static final String COMPILER_PB_UNREACHABLE_CODE= PLUGIN_ID + ".compiler.problem.unreachableCode"; //$NON-NLS-1$
/**
* @deprecated Discontinued since turning off would violate language specs.
* @category DeprecatedOptionID
*/
public static final String COMPILER_PB_INVALID_IMPORT= PLUGIN_ID + ".compiler.problem.invalidImport"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Attempt to Override Package Visible Method.
* <p>
* A package visible method, which is any method that is not explicitly declared as public,
* protected or private, is not visible from other packages, and thus cannot be overridden from
* another package. Attempting to override a package visible method from another package
* introduces a new method that is unrelated to the original one. When enabling this option, the
* compiler will signal such situations as an error or a warning.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_PB_OVERRIDING_PACKAGE_DEFAULT_METHOD= PLUGIN_ID + ".compiler.problem.overridingPackageDefaultMethod"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Method With Constructor Name.
* <p>
* Naming a method with a constructor name is generally considered poor style programming. When
* enabling this option, the compiler will signal such scenarii either as an error or a warning.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME= PLUGIN_ID + ".compiler.problem.methodWithConstructorName"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Deprecation.
* <p>
* When enabled, the compiler will signal use of deprecated API either as an error or a warning.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.deprecation"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_PB_DEPRECATION= PLUGIN_ID + ".compiler.problem.deprecation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Deprecation Inside Deprecated Code.
* <p>
* When enabled, the compiler will signal use of deprecated API inside deprecated code.
* <p>
* The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE= PLUGIN_ID + ".compiler.problem.deprecationInDeprecatedCode"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Deprecation When Overriding Deprecated Method.
* <p>
* When enabled, the compiler will signal the declaration of a method overriding a deprecated
* one.
* <p>
* The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"</code>
* </dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_DEPRECATION_WHEN_OVERRIDING_DEPRECATED_METHOD= "org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Hidden Catch Block.
* <p>
* Locally to a try statement, some catch blocks may hide others. For example,
*
* <pre>
* try { throw new java.io.CharConversionException();
* } catch (java.io.CharConversionException e) {
* } catch (java.io.IOException e) {}.
* </pre>
*
* When enabling this option, the compiler will issue an error or a warning for hidden catch
* blocks corresponding to checked exceptions.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_PB_HIDDEN_CATCH_BLOCK= PLUGIN_ID + ".compiler.problem.hiddenCatchBlock"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Local.
* <p>
* When enabled, the compiler will issue an error or a warning for unused local variables (that
* is, variables never read from).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLocal"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_LOCAL= PLUGIN_ID + ".compiler.problem.unusedLocal"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Parameter.
* <p>
* When enabled, the compiler will issue an error or a warning for unused method parameters
* (that is, parameters never read from).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameter"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_PARAMETER= PLUGIN_ID + ".compiler.problem.unusedParameter"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Parameter if Implementing Abstract Method.
* <p>
* When enabled, the compiler will signal unused parameters in abstract method implementations.
* <p>
* The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_PARAMETER_WHEN_IMPLEMENTING_ABSTRACT= PLUGIN_ID + ".compiler.problem.unusedParameterWhenImplementingAbstract"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Parameter if Overriding Concrete Method.
* <p>
* When enabled, the compiler will signal unused parameters in methods overriding concrete ones.
* <p>
* The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_PARAMETER_WHEN_OVERRIDING_CONCRETE= PLUGIN_ID + ".compiler.problem.unusedParameterWhenOverridingConcrete"; //$NON-NLS-1$
/**
* Compiler option ID: Consider Reference in Doc Comment for Unused Parameter Check.
* <p>
* When enabled, the compiler will consider doc comment references to parameters (i.e.
* <code>@param</code> clauses) for the unused parameter check. Thus, documented parameters will
* be considered as mandated as per doc contract.
* <p>
* The severity of the unused parameter problem is controlled with option
* {@link #COMPILER_PB_UNUSED_PARAMETER}.
* <p>
* Note: this option has no effect until the doc comment support is enabled according to the
* option {@link #COMPILER_DOC_COMMENT_SUPPORT}.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference"</code>
* </dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.3
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE= PLUGIN_ID + ".compiler.problem.unusedParameterIncludeDocCommentReference"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Import.
* <p>
* When enabled, the compiler will issue an error or a warning for unused import reference.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unusedImport"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 2.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_IMPORT= PLUGIN_ID + ".compiler.problem.unusedImport"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Presence of Type Arguments for a Non-Generic Method Invocation.
* <p>
* When enabled, the compiler will issue an error or a warning whenever type arguments are
* encountered for a non-generic method invocation. Note that prior to compliance level is
* <code>"1.7"</code>, this situation would automatically result in an error. From Java7 on,
* unused type arguments are being tolerated, and optionally warned against.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.4
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_TYPE_ARGUMENTS_FOR_METHOD_INVOCATION= PLUGIN_ID + ".compiler.problem.unusedTypeArgumentsForMethodInvocation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Synthetic Access Emulation.
* <p>
* When enabled, the compiler will issue an error or a warning whenever it emulates access to a
* non-accessible member of an enclosing type. Such access can have performance implications.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @category CompilerOptionID
*/
public static final String COMPILER_PB_SYNTHETIC_ACCESS_EMULATION= PLUGIN_ID + ".compiler.problem.syntheticAccessEmulation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Non-Externalized String Literal.
* <p>
* When enabled, the compiler will issue an error or a warning for non externalized String
* literal (that is, not tagged with <code>//$NON-NLS-<n>$</code>).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 2.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_NON_NLS_STRING_LITERAL= PLUGIN_ID + ".compiler.problem.nonExternalizedStringLiteral"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Usage of <code>'assert'</code> Identifier.
* <p>
* When enabled, the compiler will issue an error or a warning whenever <code>'assert'</code> is
* used as an identifier (reserved keyword in 1.4).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.assertIdentifier"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 2.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_ASSERT_IDENTIFIER= PLUGIN_ID + ".compiler.problem.assertIdentifier"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Usage of <code>'enum'</code> Identifier.
* <p>
* When enabled, the compiler will issue an error or a warning whenever <code>'enum'</code> is
* used as an identifier (reserved keyword in 1.5).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.enumIdentifier"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_ENUM_IDENTIFIER= PLUGIN_ID + ".compiler.problem.enumIdentifier"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Non-Static Reference to a Static Member.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a static field or method
* is accessed with an expression receiver. A reference to a static member should be qualified
* with a type name.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_STATIC_ACCESS_RECEIVER= PLUGIN_ID + ".compiler.problem.staticAccessReceiver"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Indirect Reference to a Static Member.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a static field or method
* is accessed in an indirect way. A reference to a static member should preferably be qualified
* with its declaring type name.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INDIRECT_STATIC_ACCESS= PLUGIN_ID + ".compiler.problem.indirectStaticAccess"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Assignment with no Effect.
* <p>
* When enabled, the compiler will issue an error or a warning whenever an assignment has no
* effect (e.g <code>'x = x'</code>).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.noEffectAssignment"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_NO_EFFECT_ASSIGNMENT= PLUGIN_ID + ".compiler.problem.noEffectAssignment"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Interface Method not Compatible with non-Inherited Methods.
* <p>
* When enabled, the compiler will issue an error or a warning whenever an interface defines a
* method incompatible with a non-inherited <code>Object</code> method. Until this conflict is
* resolved, such an interface cannot be implemented, For example,
*
* <pre>
* interface I {
* int clone();
* }
* </pre>
*
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INCOMPATIBLE_NON_INHERITED_INTERFACE_METHOD= PLUGIN_ID + ".compiler.problem.incompatibleNonInheritedInterfaceMethod"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Private Members.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a private method or
* field is declared but never used within the same unit.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_PRIVATE_MEMBER= PLUGIN_ID + ".compiler.problem.unusedPrivateMember"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Local Variable Declaration Hiding another Variable.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a local variable
* declaration is hiding some field or local variable (either locally, inherited or defined in
* enclosing type).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.localVariableHiding"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_LOCAL_VARIABLE_HIDING= PLUGIN_ID + ".compiler.problem.localVariableHiding"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Special Parameter Hiding another Field.
* <p>
* When enabled, the compiler will signal cases where a constructor or setter method parameter
* declaration is hiding some field (either locally, inherited or defined in enclosing type).
* <p>
* The severity of the problem is controlled with option
* {@link #COMPILER_PB_LOCAL_VARIABLE_HIDING}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD= PLUGIN_ID + ".compiler.problem.specialParameterHidingField"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Field Declaration Hiding another Variable.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a field declaration is
* hiding some field or local variable (either locally, inherited or defined in enclosing type).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.fieldHiding"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_FIELD_HIDING= PLUGIN_ID + ".compiler.problem.fieldHiding"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Type Declaration Hiding another Type.
* <p>
* When enabled, the compiler will issue an error or a warning in situations where a type
* parameter declaration is hiding some type, when a nested type is hiding some type parameter,
* or when a nested type is hiding another nested type defined in same unit.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.typeParameterHiding"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_TYPE_PARAMETER_HIDING= PLUGIN_ID + ".compiler.problem.typeParameterHiding"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Possible Accidental Boolean Assignment.
* <p>
* When enabled, the compiler will issue an error or a warning if a boolean assignment is acting
* as the condition of a control statement (where it probably was meant to be a boolean
* comparison).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT= PLUGIN_ID + ".compiler.problem.possibleAccidentalBooleanAssignment"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Switch Fall-Through Case.
* <p>
* When enabled, the compiler will issue an error or a warning if a case may be entered by
* falling through previous case. Empty cases are allowed.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.fallthroughCase"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.2
* @category CompilerOptionID
*/
public static final String COMPILER_PB_FALLTHROUGH_CASE= PLUGIN_ID + ".compiler.problem.fallthroughCase"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Empty Statements and Unnecessary Semicolons.
* <p>
* When enabled, the compiler will issue an error or a warning if an empty statement or a
* unnecessary semicolon is encountered.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.emptyStatement"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_EMPTY_STATEMENT= PLUGIN_ID + ".compiler.problem.emptyStatement"; //$NON-NLS-1$
/**
* Compiler option ID.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.booleanMethodThrowingException"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
* @deprecated - this option has no effect
*/
public static final String COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION= PLUGIN_ID + ".compiler.problem.booleanMethodThrowingException"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unnecessary Type Check.
* <p>
* When enabled, the compiler will issue an error or a warning when a cast or an
* <code>instanceof</code> operation is unnecessary.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNNECESSARY_TYPE_CHECK= PLUGIN_ID + ".compiler.problem.unnecessaryTypeCheck"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unnecessary Else.
* <p>
* When enabled, the compiler will issue an error or a warning when a statement is unnecessarily
* nested within an <code>else</code> clause (in situation where then clause is not completing
* normally).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryElse"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNNECESSARY_ELSE= PLUGIN_ID + ".compiler.problem.unnecessaryElse"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Undocumented Empty Block.
* <p>
* When enabled, the compiler will issue an error or a warning when an empty block is detected
* and it is not documented with any comment.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNDOCUMENTED_EMPTY_BLOCK= PLUGIN_ID + ".compiler.problem.undocumentedEmptyBlock"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Finally Blocks Not Completing Normally.
* <p>
* When enabled, the compiler will issue an error or a warning when a finally block does not
* complete normally.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_FINALLY_BLOCK_NOT_COMPLETING= PLUGIN_ID + ".compiler.problem.finallyBlockNotCompletingNormally"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Declared Thrown Exception.
* <p>
* When enabled, the compiler will issue an error or a warning when a method or a constructor is
* declaring a checked exception as thrown, but its body actually raises neither that exception,
* nor any other exception extending it.
* <p>
* This diagnostic is further tuned by options
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE},
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE}, and
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION= PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownException"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Declared Thrown Exception in Overriding Method.
* <p>
* When disabled, the compiler will report unused declared thrown exceptions neither on
* overriding methods nor on implementing methods.
* <p>
* The severity of the unused declared thrown exception problem is controlled with option
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.
* <p>
* This diagnostic is further tuned by options
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE} and
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE}.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"</code>
* </dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING= PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"; //$NON-NLS-1$
/**
* Compiler option ID: Consider Reference in Doc Comment for Unused Declared Thrown Exception
* Check.
* <p>
* When enabled, the compiler will consider doc comment references to exceptions (i.e.
* <code>@throws</code> clauses) for the unused declared thrown exception check. Thus,
* documented exceptions will be considered as mandated as per doc contract.
* <p>
* The severity of the unused declared thrown exception problem is controlled with option
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.
* <p>
* Note: this option has no effect until the doc comment support is enabled according to the
* option {@link #COMPILER_DOC_COMMENT_SUPPORT}.
* <p>
* This diagnostic is further tuned by options
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE} and
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"</code>
* </dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.4
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE= PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unused Declared Thrown Exception Exempts Exception And
* Throwable.
* <p>
* When enabled, the compiler will issue an error or a warning when a method or a constructor is
* declaring a checked exception else than {@link java.lang.Throwable} or
* {@link java.lang.Exception} as thrown, but its body actually raises neither that exception,
* nor any other exception extending it. When disabled, the compiler will issue an error or a
* warning when a method or a constructor is declaring a checked exception (including
* {@link java.lang.Throwable} and {@link java.lang.Exception}) as thrown, but its body actually
* raises neither that exception, nor any other exception extending it.
* <p>
* The severity of the unused declared thrown exception problem is controlled with option
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.
* <p>
* This diagnostic is further tuned by options
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE} and
* {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable"</code>
* </dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.4
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE= PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unqualified Access to Field.
* <p>
* When enabled, the compiler will issue an error or a warning when a field is access without
* any qualification. In order to improve code readability, it should be qualified, e.g.
* <code>'x'</code> should rather be written <code>'this.x'</code>.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNQUALIFIED_FIELD_ACCESS= PLUGIN_ID + ".compiler.problem.unqualifiedFieldAccess"; //$NON-NLS-1$
/**
* @deprecated Use {@link #COMPILER_PB_UNCHECKED_TYPE_OPERATION} instead.
* @since 3.1
* @category DeprecatedOptionID
*/
public static final String COMPILER_PB_UNSAFE_TYPE_OPERATION= PLUGIN_ID + ".compiler.problem.uncheckedTypeOperation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unchecked Type Operation.
* <p>
* When enabled, the compiler will issue an error or a warning whenever an operation involves
* generic types, and potentially invalidates type safety since involving raw types (e.g.
* invoking <code>#foo(X<String>)</code> with arguments <code>(X)</code>).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNCHECKED_TYPE_OPERATION= PLUGIN_ID + ".compiler.problem.uncheckedTypeOperation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Raw Type Reference.
* <p>
* When enabled, the compiler will issue an error or a warning when detecting references to raw
* types. Raw types are discouraged, and are intended to help interfacing with legacy code. In
* the future, the language specification may reject raw references to generic types.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.rawTypeReference"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.2
* @category CompilerOptionID
*/
public static final String COMPILER_PB_RAW_TYPE_REFERENCE= PLUGIN_ID + ".compiler.problem.rawTypeReference"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting final Bound for Type Parameter.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a generic type parameter
* is associated with a bound corresponding to a final type; since final types cannot be further
* extended, the parameter is pretty useless.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.finalParameterBound"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_FINAL_PARAMETER_BOUND= PLUGIN_ID + ".compiler.problem.finalParameterBound"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing Declaration of serialVersionUID Field on Serializable
* Class.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a serializable class is
* missing a local declaration of a <code>serialVersionUID</code> field. This field must be
* declared as static final and be of type <code>long</code>.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingSerialVersion"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_SERIAL_VERSION= PLUGIN_ID + ".compiler.problem.missingSerialVersion"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Varargs Argument Needing a Cast in Method/Constructor
* Invocation.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a varargs arguments
* should be cast when passed to a method/constructor invocation. (e.g.
* <code>Class.getMethod(String name, Class ... args )</code> invoked with arguments
* <code>("foo", null)</code>).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_VARARGS_ARGUMENT_NEED_CAST= PLUGIN_ID + ".compiler.problem.varargsArgumentNeedCast"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Boxing/Unboxing Conversion.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a boxing or an unboxing
* conversion is performed.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.autoboxing"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_AUTOBOXING= PLUGIN_ID + ".compiler.problem.autoboxing"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Use of Annotation Type as Super Interface.
* <p>
* When enabled, the compiler will issue an error or a warning whenever an annotation type is
* used as a super-interface. Though legal, this is discouraged.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_ANNOTATION_SUPER_INTERFACE= PLUGIN_ID + ".compiler.problem.annotationSuperInterface"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing <code>@Override</code> Annotation.
* <p>
* When enabled, the compiler will issue an error or a warning whenever encountering a method
* declaration which overrides a superclass method but has no <code>@Override</code> annotation.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_OVERRIDE_ANNOTATION= PLUGIN_ID + ".compiler.problem.missingOverrideAnnotation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing <code>@Override</code> Annotation for interface method
* implementation.
* <p>
* When enabled, the compiler will issue an error or a warning whenever encountering a method
* declaration which overrides or implements a superinterface method but has no
* <code>@Override</code> annotation.
* </p>
* <p>
* This option only has an effect if the compiler compliance is 1.6 or greater.
* </p>
* <p>
* The severity of the problem is controlled with option
* {@link #COMPILER_PB_MISSING_OVERRIDE_ANNOTATION}.
* </p>
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation"</code>
* </dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.6
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_OVERRIDE_ANNOTATION_FOR_INTERFACE_METHOD_IMPLEMENTATION= PLUGIN_ID + ".compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing <code>@Deprecated</code> Annotation.
* <p>
* When enabled, the compiler will issue an error or a warning whenever encountering a
* declaration carrying a <code>@deprecated</code> doc tag but having no corresponding
* <code>@Deprecated</code> annotation.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_DEPRECATED_ANNOTATION= PLUGIN_ID + ".compiler.problem.missingDeprecatedAnnotation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing HashCode Method.
* <p>
* When enabled, the compiler will issue an error or a warning if a type overrides
* Object.equals(Object) but does not override hashCode().
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.5
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_HASHCODE_METHOD= PLUGIN_ID + ".compiler.problem.missingHashCodeMethod"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Dead Code.
* <p>
* When enabled, the compiler will issue an error or a warning if some non fatal dead code is
* detected. For instance, <code>if (false) foo();</code> is not reported as truly unreachable
* code by the Java Language Specification. If this diagnostic is enabled, then the invocation
* of <code>foo()</code> is going to be signaled as being dead code.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.deadCode"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.5
* @category CompilerOptionID
*/
public static final String COMPILER_PB_DEAD_CODE= PLUGIN_ID + ".compiler.problem.deadCode"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Dead Code Inside Trivial If Statement.
* <p>
* When enabled, the compiler will signal presence of dead code inside trivial IF statement,
* e.g. <code>if (DEBUG)...</code>..
* <p>
* The severity of the problem is controlled with option {@link #COMPILER_PB_DEAD_CODE}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.deadCodeInTrivialIfStatement"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.5
* @category CompilerOptionID
*/
public static final String COMPILER_PB_DEAD_CODE_IN_TRIVIAL_IF_STATEMENT= PLUGIN_ID + ".compiler.problem.deadCodeInTrivialIfStatement"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Incomplete Enum Switch.
* <p>
* When enabled, the compiler will issue an error or a warning whenever an enum constant has no
* corresponding case label in an enum switch statement.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INCOMPLETE_ENUM_SWITCH= PLUGIN_ID + ".compiler.problem.incompleteEnumSwitch"; //$NON-NLS-1$
/**
* @since 3.1
* @deprecated Use {@link #COMPILER_PB_NULL_REFERENCE} instead.
* @category DeprecatedOptionID
*/
public static final String COMPILER_PB_INCONSISTENT_NULL_CHECK= PLUGIN_ID + ".compiler.problem.inconsistentNullCheck"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unreferenced Label.
* <p>
* When enabled, the compiler will issue an error or a warning when encountering a labeled
* statement which label is never explicitly referenced. A label is considered to be referenced
* if its name explicitly appears behind a break or continue statement; for instance the
* following label would be considered unreferenced: <code>LABEL: { break; }</code>
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLabel"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.2
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_LABEL= PLUGIN_ID + ".compiler.problem.unusedLabel"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Invalid Javadoc Comment.
* <p>
* This is the generic control for the severity of Javadoc problems. When enabled, the compiler
* will issue an error or a warning for a problem in Javadoc.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadoc"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INVALID_JAVADOC= PLUGIN_ID + ".compiler.problem.invalidJavadoc"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Invalid Javadoc Tags.
* <p>
* When enabled, the compiler will signal unbound or unexpected reference tags in Javadoc. A
* <code>@throws</code> tag referencing an undeclared exception would be considered as
* unexpected.
* <p>
* Note that this diagnosis can be enabled based on the visibility of the construct associated
* with the Javadoc; also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTags"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INVALID_JAVADOC_TAGS= PLUGIN_ID + ".compiler.problem.invalidJavadocTags"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Invalid Javadoc Tags with Deprecated References.
* <p>
* Specify whether the compiler will report deprecated references used in Javadoc tags.
* <p>
* Note that this diagnosis can be enabled based on the visibility of the construct associated
* with the Javadoc; also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INVALID_JAVADOC_TAGS__DEPRECATED_REF= PLUGIN_ID + ".compiler.problem.invalidJavadocTagsDeprecatedRef"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Invalid Javadoc Tags with Not Visible References.
* <p>
* Specify whether the compiler will report non-visible references used in Javadoc tags.
* <p>
* Note that this diagnosis can be enabled based on the visibility of the construct associated
* with the Javadoc; also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INVALID_JAVADOC_TAGS__NOT_VISIBLE_REF= PLUGIN_ID + ".compiler.problem.invalidJavadocTagsNotVisibleRef"; //$NON-NLS-1$
/**
* Compiler option ID: Visibility Level For Invalid Javadoc Tags.
* <p>
* Set the minimum visibility level for Javadoc tag problems. Below this level problems will be
* ignored.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "public", "protected", "default", "private" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"public"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY= PLUGIN_ID + ".compiler.problem.invalidJavadocTagsVisibility"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting missing tag description.
* <p>
* When enabled, the compiler will report a warning or an error for any Javadoc tag missing a
* required description.
* <p>
* The severity of the problem is controlled with option {@link #COMPILER_PB_INVALID_JAVADOC}.
* <p>
* It does not depend on option {@link #COMPILER_PB_INVALID_JAVADOC_TAGS}.
* <p>
* When this option is valued to
* {@link #COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_STANDARD_TAGS}, a subset of the
* standard <a
* href="http://java.sun.com/javase/6/docs/technotes/tools/windows/javadoc.html#javadoctags"
* >Javadoc tags</a> that have a description, text or label are checked. While this set may grow
* in the future, note that user-defined tags are not and will not be checked.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "return_tag", "all_standard_tags", "no_tag" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"return_tag"</code></dd>
* </dl>
*
* @since 3.4
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION= PLUGIN_ID + ".compiler.problem.missingJavadocTagDescription"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing Javadoc Tags.
* <p>
* This is the generic control for the severity of Javadoc missing tag problems. When enabled,
* the compiler will issue an error or a warning when tags are missing in Javadoc comments.
* <p>
* Note that this diagnosis can be enabled based on the visibility of the construct associated
* with the Javadoc; also see the setting {@link #COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTags"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_JAVADOC_TAGS= PLUGIN_ID + ".compiler.problem.missingJavadocTags"; //$NON-NLS-1$
/**
* Compiler option ID: Visibility Level For Missing Javadoc Tags.
* <p>
* Set the minimum visibility level for Javadoc missing tag problems. Below this level problems
* will be ignored.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "public", "protected", "default", "private" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"public"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY= PLUGIN_ID + ".compiler.problem.missingJavadocTagsVisibility"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing Javadoc Tags on Overriding Methods.
* <p>
* Specify whether the compiler will verify overriding methods in order to report Javadoc
* missing tag problems.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING= PLUGIN_ID + ".compiler.problem.missingJavadocTagsOverriding"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing Javadoc Comments.
* <p>
* This is the generic control for the severity of missing Javadoc comment problems. When
* enabled, the compiler will issue an error or a warning when Javadoc comments are missing.
* <p>
* Note that this diagnosis can be enabled based on the visibility of the construct associated
* with the expected Javadoc; also see the setting
* {@link #COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY}.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocComments"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS= PLUGIN_ID + ".compiler.problem.missingJavadocComments"; //$NON-NLS-1$
/**
* Compiler option ID: Visibility Level For Missing Javadoc Comments.
* <p>
* Set the minimum visibility level for missing Javadoc problems. Below this level problems will
* be ignored.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "public", "protected", "default", "private" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"public"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY= PLUGIN_ID + ".compiler.problem.missingJavadocCommentsVisibility"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing Javadoc Comments on Overriding Methods.
* <p>
* Specify whether the compiler will verify overriding methods in order to report missing
* Javadoc comment problems.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING= PLUGIN_ID + ".compiler.problem.missingJavadocCommentsOverriding"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Usage of <code>char[]</code> Expressions in String
* Concatenations.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a <code>char[]</code>
* expression is used in String concatenations (for example,
* <code>"hello" + new char[]{'w','o','r','l','d'}</code>).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION= PLUGIN_ID + ".compiler.problem.noImplicitStringConversion"; //$NON-NLS-1$
/**
* Compiler option ID: Maximum Number of Problems Reported per Compilation Unit.
* <p>
* Specify the maximum number of problems reported on each compilation unit.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.maxProblemPerUnit"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>"<n>"</code> where <code><n></code> is zero or a positive integer (if
* zero then all problems are reported).</dd>
* <dt>Default:</dt>
* <dd><code>"100"</code></dd>
* </dl>
*
* @since 2.0
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MAX_PER_UNIT= PLUGIN_ID + ".compiler.maxProblemPerUnit"; //$NON-NLS-1$
/**
* Compiler option ID: Treating Optional Error as Fatal.
* <p>
* When enabled, optional errors (i.e. optional problems which severity is set to
* <code>"error"</code>) will be treated as standard compiler errors, yielding problem
* methods/types preventing from running offending code until the issue got resolved.
* </p>
* <p>
* When disabled, optional errors are only considered as warnings, still carrying an error
* indication to make them more severe. Note that by default, optional errors are not fatal.
* Non-optional errors are always fatal.
* </p>
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.fatalOptionalError"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.2
* @category CompilerOptionID
*/
public static final String COMPILER_PB_FATAL_OPTIONAL_ERROR= PLUGIN_ID + ".compiler.problem.fatalOptionalError"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Parameter Assignment.
* <p>
* When enabled, the compiler will issue an error or a warning if a parameter is assigned to.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.parameterAssignment"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.2
* @category CompilerOptionID
*/
public static final String COMPILER_PB_PARAMETER_ASSIGNMENT= PLUGIN_ID + ".compiler.problem.parameterAssignment"; //$NON-NLS-1$
/**
* Compiler option ID: Setting Source Compatibility Mode.
* <p>
* Specify whether which source level compatibility is used. From 1.4 on, <code>'assert'</code>
* is a keyword reserved for assertion support. Also note, than when toggling to 1.4 mode, the
* target VM level should be set to <code>"1.4"</code> and the compliance mode should be
* <code>"1.4"</code>.
* <p>
* Source level 1.5 is necessary to enable generics, autoboxing, covariance, annotations,
* enumerations enhanced for loop, static imports and varargs. Once toggled, the target VM level
* should be set to <code>"1.5"</code> and the compliance mode should be <code>"1.5"</code>.
* <p>
* Source level 1.6 is necessary to enable the computation of stack map tables. Once toggled,
* the target VM level should be set to <code>"1.6"</code> and the compliance mode should be
* <code>"1.6"</code>.
* <p>
* Once the source level 1.7 is toggled, the target VM level should be set to <code>"1.7"</code>
* and the compliance mode should be <code>"1.7"</code>.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.source"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "1.3", "1.4", "1.5", "1.6", "1.7" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"1.3"</code></dd>
* </dl>
*
* @since 2.0
* @category CompilerOptionID
*/
public static final String COMPILER_SOURCE= PLUGIN_ID + ".compiler.source"; //$NON-NLS-1$
/**
* Compiler option ID: Setting Compliance Level.
* <p>
* Select the compliance level for the compiler. In <code>"1.3"</code> mode, source and target
* settings should not go beyond <code>"1.3"</code> level.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.compliance"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "1.3", "1.4", "1.5", "1.6", "1.7" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"1.4"</code></dd>
* </dl>
*
* @since 2.0
* @category CompilerOptionID
*/
public static final String COMPILER_COMPLIANCE= PLUGIN_ID + ".compiler.compliance"; //$NON-NLS-1$
/**
* Compiler option ID: Defining the Automatic Task Priorities.
* <p>
* In parallel with the Automatic Task Tags, this list defines the priorities (high, normal or
* low) of the task markers issued by the compiler. If the default is specified, the priority of
* each task marker is <code>"NORMAL"</code>.
* </p>
* <p>
* Task Priorities and task tags must have the same length. If task priorities are set, then
* task tags should also be set.
* </p>
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.taskPriorities"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<priority>[,<priority>]*" }</code> where
* <code><priority></code> is one of <code>"HIGH"</code>, <code>"NORMAL"</code> or
* <code>"LOW"</code></dd>
* <dt>Default:</dt>
* <dd><code>"NORMAL,HIGH,NORMAL"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
* @see #COMPILER_TASK_TAGS
*/
public static final String COMPILER_TASK_PRIORITIES= PLUGIN_ID + ".compiler.taskPriorities"; //$NON-NLS-1$
/**
* Compiler option ID: Defining the Automatic Task Tags.
* <p>
* When the tag list is not empty, the compiler will issue a task marker whenever it encounters
* one of the corresponding tags inside any comment in Java source code.
* <p>
* Generated task messages will start with the tag, and range until the next line separator,
* comment ending, or tag.
* </p>
* <p>
* When a given line of code bears multiple tags, each tag will be reported separately.
* Moreover, a tag immediately followed by another tag will be reported using the contents of
* the next non-empty tag of the line, if any.
* </p>
* <p>
* Note that tasks messages are trimmed. If a tag is starting with a letter or digit, then it
* cannot be leaded by another letter or digit to be recognized (<code>"fooToDo"</code> will not
* be recognized as a task for tag <code>"ToDo"</code>, but <code>"foo#ToDo"</code> will be
* detected for either tag <code>"ToDo"</code> or <code>"#ToDo"</code>). Respectively, a tag
* ending with a letter or digit cannot be followed by a letter or digit to be recognized (
* <code>"ToDofoo"</code> will not be recognized as a task for tag <code>"ToDo"</code>, but
* <code>"ToDo:foo"</code> will be detected either for tag <code>"ToDo"</code> or
* <code>"ToDo:"</code>).
* </p>
* <p>
* Task Priorities and task tags must have the same length. If task tags are set, then task
* priorities should also be set.
* </p>
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.taskTags"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<tag>[,<tag>]*" }</code> where <code><tag></code> is a String
* without any wild-card or leading/trailing spaces</dd>
* <dt>Default:</dt>
* <dd><code>"TODO,FIXME,XXX"</code></dd>
* </dl>
*
* @since 2.1
* @category CompilerOptionID
* @see #COMPILER_TASK_PRIORITIES
*/
public static final String COMPILER_TASK_TAGS= PLUGIN_ID + ".compiler.taskTags"; //$NON-NLS-1$
/**
* Compiler option ID: Determining whether task tags are case-sensitive.
* <p>
* When enabled, task tags are considered in a case-sensitive way.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.taskCaseSensitive"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.0
* @category CompilerOptionID
*/
public static final String COMPILER_TASK_CASE_SENSITIVE= PLUGIN_ID + ".compiler.taskCaseSensitive"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Forbidden Reference to Type with Restricted Access.
* <p>
* When enabled, the compiler will issue an error or a warning when referring to a type that is
* non accessible, as defined according to the access rule specifications.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.forbiddenReference"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"error"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_FORBIDDEN_REFERENCE= PLUGIN_ID + ".compiler.problem.forbiddenReference"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Discouraged Reference to Type with Restricted Access.
* <p>
* When enabled, the compiler will issue an error or a warning when referring to a type with
* discouraged access, as defined according to the access rule specifications.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.discouragedReference"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_DISCOURAGED_REFERENCE= PLUGIN_ID + ".compiler.problem.discouragedReference"; //$NON-NLS-1$
/**
* Compiler option ID: Determining Effect of <code>@SuppressWarnings</code>.
* <p>
* When enabled, the <code>@SuppressWarnings</code> annotation can be used to suppress some
* compiler warnings.
* <p>
* When disabled, all <code>@SupressWarnings</code> annotations are ignored; i.e., warnings are
* reported.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.suppressWarnings"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_SUPPRESS_WARNINGS= PLUGIN_ID + ".compiler.problem.suppressWarnings"; //$NON-NLS-1$
/**
* Compiler option ID: Further Determining the Effect of <code>@SuppressWarnings</code> if also
* {@link #COMPILER_PB_SUPPRESS_WARNINGS} is enabled.
* <p>
* When enabled, the <code>@SuppressWarnings</code> annotation can additionally be used to
* suppress optional compiler diagnostics that have been configured as {@link #ERROR}.
* <p>
* When disabled, all <code>@SuppressWarnings</code> annotations only affects warnings.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.6
* @category CompilerOptionID
*/
public static final String COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS= PLUGIN_ID + ".compiler.problem.suppressOptionalErrors"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unhandled Warning Token for <code>@SuppressWarnings</code>.
* <p>
* When enabled, the compiler will issue an error or a warning when encountering a token it
* cannot handle inside a <code>@SuppressWarnings</code> annotation.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNHANDLED_WARNING_TOKEN= PLUGIN_ID + ".compiler.problem.unhandledWarningToken"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Unnecessary <code>@SuppressWarnings</code>.
* <p>
* When enabled, the compiler will issue an error or a warning when encountering
* <code>@SuppressWarnings</code> annotation for which no corresponding warning got detected in
* the code. This diagnostic is provided to help developers to get rid of transient
* <code>@SuppressWarnings</code> no longer needed. Note that
* <code>@SuppressWarnings("all")</code> is still silencing the warning for unnecessary
* <code>@SuppressWarnings</code>, as it is the master switch to silence ALL warnings.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unusedWarningToken"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.4
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_WARNING_TOKEN= PLUGIN_ID + ".compiler.problem.unusedWarningToken"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Null Dereference.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a variable that is
* statically known to hold a null value is used to access a field or method.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.nullReference"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.2
* @category CompilerOptionID
*/
public static final String COMPILER_PB_NULL_REFERENCE= PLUGIN_ID + ".compiler.problem.nullReference"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Potential Null Dereference.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a variable that has
* formerly been tested against null but is not (no more) statically known to hold a non-null
* value is used to access a field or method.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.potentialNullReference"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.3
* @category CompilerOptionID
*/
public static final String COMPILER_PB_POTENTIAL_NULL_REFERENCE= PLUGIN_ID + ".compiler.problem.potentialNullReference"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Redundant Null Check.
* <p>
* When enabled, the compiler will issue an error or a warning whenever a variable that is
* statically known to hold a null or a non-null value is tested against null.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.redundantNullCheck"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.3
* @category CompilerOptionID
*/
public static final String COMPILER_PB_REDUNDANT_NULL_CHECK= PLUGIN_ID + ".compiler.problem.redundantNullCheck"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Overriding method that doesn't call the super method
* invocation.
* <p>
* When enabled, the compiler will issue an error or a warning if a method is overriding a
* method without calling the super invocation.
* <dl>
* <dt>Option id:</dt>
* <dd>
* <code>"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.3
* @category CompilerOptionID
*/
public static final String COMPILER_PB_OVERRIDING_METHOD_WITHOUT_SUPER_INVOCATION= PLUGIN_ID + ".compiler.problem.overridingMethodWithoutSuperInvocation"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Redundant Superinterface.
* <p>
* When enabled, the compiler will issue an error or a warning if a type explicitly implements
* an interface that is already implemented by any of its supertypes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.4
* @category CompilerOptionID
*/
public static final String COMPILER_PB_REDUNDANT_SUPERINTERFACE= PLUGIN_ID + ".compiler.problem.redundantSuperinterface"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Comparison of Identical Expressions.
* <p>
* When enabled, the compiler will issue an error or a warning if a comparison is involving
* identical operands (e.g <code>'x == x'</code>).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.comparingIdentical"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 3.5
* @category CompilerOptionID
*/
public static final String COMPILER_PB_COMPARING_IDENTICAL= PLUGIN_ID + ".compiler.problem.comparingIdentical"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing Synchronized Modifier On Inherited Method.
* <p>
* When enabled, the compiler will issue an error or a warning if a method overrides a
* synchronized method without having a synchronized modifier.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod"</code>
* </dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.5
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD= PLUGIN_ID + ".compiler.problem.missingSynchronizedOnInheritedMethod"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Allocation of an Unused Object.
* <p>
* When enabled, the compiler will issue an error or a warning if an object is allocated but
* never used, neither by holding a reference nor by invoking one of the object's methods.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.6
* @category CompilerOptionID
*/
public static final String COMPILER_PB_UNUSED_OBJECT_ALLOCATION= PLUGIN_ID + ".compiler.problem.unusedObjectAllocation"; //$NON-NLS-1$
/**
* Core option ID: Computing Project Build Order.
* <p>
* Indicate whether JavaCore should enforce the project build order to be based on the classpath
* prerequisite chain. When requesting to compute, this takes over the platform default order
* (based on project references).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.computeJavaBuildOrder"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "compute", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @category CoreOptionID
*/
public static final String CORE_JAVA_BUILD_ORDER= PLUGIN_ID + ".computeJavaBuildOrder"; //$NON-NLS-1$
/**
* Core option ID: Specifying Filters for Resource Copying Control.
* <p>
* Allow to specify some filters to control the resource copy process.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.builder.resourceCopyExclusionFilter"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<name>[,<name>]* }</code> where <code><name></code> is a file
* name pattern (* and ? wild-cards allowed) or the name of a folder which ends with
* <code>'/'</code></dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.0
* @category CoreOptionID
*/
public static final String CORE_JAVA_BUILD_RESOURCE_COPY_FILTER= PLUGIN_ID + ".builder.resourceCopyExclusionFilter"; //$NON-NLS-1$
/**
* Core option ID: Reporting Duplicate Resources.
* <p>
* Indicate the severity of the problem reported when more than one occurrence of a resource is
* to be copied into the output location.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.builder.duplicateResourceTask"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"warning"</code></dd>
* </dl>
*
* @since 2.1
* @category CoreOptionID
*/
public static final String CORE_JAVA_BUILD_DUPLICATE_RESOURCE= PLUGIN_ID + ".builder.duplicateResourceTask"; //$NON-NLS-1$
/**
* Core option ID: Cleaning Output Folder(s).
* <p>
* Indicate whether the JavaBuilder is allowed to clean the output folders when performing full
* build operations.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.builder.cleanOutputFolder"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "clean", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"clean"</code></dd>
* </dl>
*
* @since 2.1
* @category CoreOptionID
*/
public static final String CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER= PLUGIN_ID + ".builder.cleanOutputFolder"; //$NON-NLS-1$
/**
* Core option ID: Recreate Modified class files in Output Folder.
* <p>
* Indicate whether the JavaBuilder should check for any changes to .class files in the output
* folders while performing incremental build operations. If changes are detected to managed
* .class files, then a full build is performed, otherwise the changes are left as is. Tools
* further altering generated .class files, like optimizers, should ensure this option remains
* set in its default state of ignore.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.2
* @category CoreOptionID
*/
public static final String CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER= PLUGIN_ID + ".builder.recreateModifiedClassFileInOutputFolder"; //$NON-NLS-1$
/**
* Core option ID: Reporting Incomplete Classpath.
* <p>
* Indicate the severity of the problem reported when an entry on the classpath does not exist,
* is not legite or is not visible (for example, a referenced project is closed).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.incompleteClasspath"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning"}</code></dd>
* <dt>Default:</dt>
* <dd><code>"error"</code></dd>
* </dl>
*
* @since 2.1
* @category CoreOptionID
*/
public static final String CORE_INCOMPLETE_CLASSPATH= PLUGIN_ID + ".incompleteClasspath"; //$NON-NLS-1$
/**
* Core option ID: Reporting Classpath Cycle.
* <p>
* Indicate the severity of the problem reported when a project is involved in a cycle.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.circularClasspath"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"error"</code></dd>
* </dl>
*
* @since 2.1
* @category CoreOptionID
*/
public static final String CORE_CIRCULAR_CLASSPATH= PLUGIN_ID + ".circularClasspath"; //$NON-NLS-1$
/**
* Core option ID: Reporting Incompatible JDK Level for Required Binaries.
* <p>
* Indicate the severity of the problem reported when a project prerequisites another project or
* library with an incompatible target JDK level (e.g. project targeting 1.1 vm, but compiled
* against 1.4 libraries).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.incompatibleJDKLevel"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "error", "warning", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"ignore"</code></dd>
* </dl>
*
* @since 3.0
* @category CoreOptionID
*/
public static final String CORE_INCOMPATIBLE_JDK_LEVEL= PLUGIN_ID + ".incompatibleJDKLevel"; //$NON-NLS-1$
/**
* Core option ID: Abort if Invalid Classpath.
* <p>
* Allow to toggle the builder to abort if the classpath is invalid.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.builder.invalidClasspath"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "abort", "ignore" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"abort"</code></dd>
* </dl>
*
* @since 2.0
* @category CoreOptionID
*/
public static final String CORE_JAVA_BUILD_INVALID_CLASSPATH= PLUGIN_ID + ".builder.invalidClasspath"; //$NON-NLS-1$
/**
* Core option ID: Default Source Encoding Format.
* <p>
* Get the default encoding format of source files. This value is immutable and preset to the
* result of <code>ResourcesPlugin.getEncoding()</code>.
* <p>
* It is offered as a convenience shortcut only.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.encoding"</code></dd>
* <dt>value:</dt>
* <dd><code><immutable, platform default value></code></dd>
* </dl>
*
* @since 2.0
* @category CoreOptionID
*/
public static final String CORE_ENCODING= PLUGIN_ID + ".encoding"; //$NON-NLS-1$
/**
* Core option ID: Enabling Usage of Classpath Exclusion Patterns.
* <p>
* When disabled, no entry on a project classpath can be associated with an exclusion pattern.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.classpath.exclusionPatterns"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 2.1
* @category CoreOptionID
*/
public static final String CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS= PLUGIN_ID + ".classpath.exclusionPatterns"; //$NON-NLS-1$
/**
* Core option ID: Enabling Usage of Classpath Multiple Output Locations.
* <p>
* When disabled, no entry on a project classpath can be associated with a specific output
* location, preventing thus usage of multiple output locations.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.classpath.multipleOutputLocations"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 2.1
* @category CoreOptionID
*/
public static final String CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS= PLUGIN_ID + ".classpath.multipleOutputLocations"; //$NON-NLS-1$
/**
* Core option ID: Set the timeout value for retrieving the method's parameter names from
* javadoc.
* <p>
* Timeout in milliseconds to retrieve the method's parameter names from javadoc.
* <p>
* If the value is <code>0</code>, the parameter names are not fetched and the raw names are
* returned.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>"<n>"</code>, where <code>n</code> is an integer greater than or equal to
* <code>0</code></dd>
* <dt>Default:</dt>
* <dd><code>"50"</code></dd>
* </dl>
*
* @since 3.2
* @category CoreOptionID
*/
public static final String TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC= PLUGIN_ID + ".timeoutForParameterNameFromAttachedJavadoc"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION}
* ,
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_BLOCK}
* ,
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION}
* ,
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION}
* ,
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_SWITCH}
* ,
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_NEWLINE_OPENING_BRACE= PLUGIN_ID + ".formatter.newline.openingBrace"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT}
* ,
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT}
* ,
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT}
* ,
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_NEWLINE_CONTROL= PLUGIN_ID + ".formatter.newline.controlStatement"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_COMPACT_ELSE_IF}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_NEWLINE_ELSE_IF= PLUGIN_ID + ".formatter.newline.elseIf"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_NEWLINE_EMPTY_BLOCK= PLUGIN_ID + ".formatter.newline.emptyBlock"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_CLEAR_BLANK_LINES= PLUGIN_ID + ".formatter.newline.clearAll"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_LINE_SPLIT}
* instead
* @category DeprecatedOptionID
*/
public static final String FORMATTER_LINE_SPLIT= PLUGIN_ID + ".formatter.lineSplit"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_COMPACT_ASSIGNMENT= PLUGIN_ID + ".formatter.style.assignment"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_TAB_CHAR}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_TAB_CHAR= PLUGIN_ID + ".formatter.tabulation.char"; //$NON-NLS-1$
/**
* @since 2.0
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_TAB_SIZE}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_TAB_SIZE= PLUGIN_ID + ".formatter.tabulation.size"; //$NON-NLS-1$
/**
* @since 2.1
* @deprecated Use
* {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST}
* instead.
* @category DeprecatedOptionID
*/
public static final String FORMATTER_SPACE_CASTEXPRESSION= PLUGIN_ID + ".formatter.space.castexpression"; //$NON-NLS-1$
/**
* Code assist option ID: Activate Visibility Sensitive Completion.
* <p>
* When active, completion doesn't show that you can not see (for example, you can not see
* private methods of a super class).
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.visibilityCheck"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 2.0
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_VISIBILITY_CHECK= PLUGIN_ID + ".codeComplete.visibilityCheck"; //$NON-NLS-1$
/**
* Code assist option ID: Activate Deprecation Sensitive Completion.
* <p>
* When enabled, completion doesn't propose deprecated members and types.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.deprecationCheck"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.2
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_DEPRECATION_CHECK= PLUGIN_ID + ".codeComplete.deprecationCheck"; //$NON-NLS-1$
/**
* Code assist option ID: Activate Camel Case Sensitive Completion.
* <p>
* When enabled, completion shows proposals whose name match the CamelCase pattern.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.camelCaseMatch"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.2
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_CAMEL_CASE_MATCH= PLUGIN_ID + ".codeComplete.camelCaseMatch"; //$NON-NLS-1$
/**
* Code assist option ID: Automatic Qualification of Implicit Members.
* <p>
* When active, completion automatically qualifies completion on implicit field references and
* message expressions.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.forceImplicitQualification"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 2.0
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_IMPLICIT_QUALIFICATION= PLUGIN_ID + ".codeComplete.forceImplicitQualification"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Prefixes for Field Name.
* <p>
* When the prefixes is non empty, completion for field name will begin with one of the proposed
* prefixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.fieldPrefixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<prefix>[,<prefix>]*" }</code> where <code><prefix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_FIELD_PREFIXES= PLUGIN_ID + ".codeComplete.fieldPrefixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Prefixes for Static Field Name.
* <p>
* When the prefixes is non empty, completion for static field name will begin with one of the
* proposed prefixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.staticFieldPrefixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<prefix>[,<prefix>]*" }</code> where <code><prefix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_STATIC_FIELD_PREFIXES= PLUGIN_ID + ".codeComplete.staticFieldPrefixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Prefixes for Static Final Field Name.
* <p>
* When the prefixes is non empty, completion for static final field name will begin with one of
* the proposed prefixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<prefix>[,<prefix>]*" }</code> where <code><prefix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 3.5
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_STATIC_FINAL_FIELD_PREFIXES= PLUGIN_ID + ".codeComplete.staticFinalFieldPrefixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Prefixes for Local Variable Name.
* <p>
* When the prefixes is non empty, completion for local variable name will begin with one of the
* proposed prefixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.localPrefixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<prefix>[,<prefix>]*" }</code> where <code><prefix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_LOCAL_PREFIXES= PLUGIN_ID + ".codeComplete.localPrefixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Prefixes for Argument Name.
* <p>
* When the prefixes is non empty, completion for argument name will begin with one of the
* proposed prefixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.argumentPrefixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<prefix>[,<prefix>]*" }</code> where <code><prefix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_ARGUMENT_PREFIXES= PLUGIN_ID + ".codeComplete.argumentPrefixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Suffixes for Field Name.
* <p>
* When the suffixes is non empty, completion for field name will end with one of the proposed
* suffixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.fieldSuffixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<suffix>[,<suffix>]*" }</code> where <code><suffix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_FIELD_SUFFIXES= PLUGIN_ID + ".codeComplete.fieldSuffixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Suffixes for Static Field Name.
* <p>
* When the suffixes is non empty, completion for static field name will end with one of the
* proposed suffixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.staticFieldSuffixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<suffix>[,<suffix>]*" }</code>< where <code><suffix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_STATIC_FIELD_SUFFIXES= PLUGIN_ID + ".codeComplete.staticFieldSuffixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Suffixes for Static Final Field Name.
* <p>
* When the suffixes is non empty, completion for static final field name will end with one of
* the proposed suffixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<suffix>[,<suffix>]*" }</code>< where <code><suffix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 3.5
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_STATIC_FINAL_FIELD_SUFFIXES= PLUGIN_ID + ".codeComplete.staticFinalFieldSuffixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Suffixes for Local Variable Name.
* <p>
* When the suffixes is non empty, completion for local variable name will end with one of the
* proposed suffixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.localSuffixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<suffix>[,<suffix>]*" }</code> where <code><suffix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_LOCAL_SUFFIXES= PLUGIN_ID + ".codeComplete.localSuffixes"; //$NON-NLS-1$
/**
* Code assist option ID: Define the Suffixes for Argument Name.
* <p>
* When the suffixes is non empty, completion for argument name will end with one of the
* proposed suffixes.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.argumentSuffixes"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "<suffix>[,<suffix>]*" }</code> where <code><suffix></code> is
* a String without any wild-card</dd>
* <dt>Default:</dt>
* <dd><code>""</code></dd>
* </dl>
*
* @since 2.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_ARGUMENT_SUFFIXES= PLUGIN_ID + ".codeComplete.argumentSuffixes"; //$NON-NLS-1$
/**
* Code assist option ID: Activate Forbidden Reference Sensitive Completion.
* <p>
* When enabled, completion doesn't propose elements which match a forbidden reference rule.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.forbiddenReferenceCheck"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_FORBIDDEN_REFERENCE_CHECK= PLUGIN_ID + ".codeComplete.forbiddenReferenceCheck"; //$NON-NLS-1$
/**
* Code assist option ID: Activate Discouraged Reference Sensitive Completion.
* <p>
* When enabled, completion doesn't propose elements which match a discouraged reference rule.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.discouragedReferenceCheck"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"disabled"</code></dd>
* </dl>
*
* @since 3.1
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_DISCOURAGED_REFERENCE_CHECK= PLUGIN_ID + ".codeComplete.discouragedReferenceCheck"; //$NON-NLS-1$
/**
* Code assist option ID: Activate Suggestion of Static Import.
* <p>
* When enabled, completion proposals can contain static import pattern.
* <dl>
* <dt>Option id:</dt>
* <dd><code>"org.eclipse.jdt.core.codeComplete.suggestStaticImports"</code></dd>
* <dt>Possible values:</dt>
* <dd><code>{ "enabled", "disabled" }</code></dd>
* <dt>Default:</dt>
* <dd><code>"enabled"</code></dd>
* </dl>
*
* @since 3.3
* @category CodeAssistOptionID
*/
public static final String CODEASSIST_SUGGEST_STATIC_IMPORTS= PLUGIN_ID + ".codeComplete.suggestStaticImports"; //$NON-NLS-1$
// end configurable option IDs }
// Begin configurable option values {
/**
* @deprecated Use {@link #DEFAULT_TASK_TAGS} instead.
* @since 2.1
* @category DeprecatedOptionValue
*/
public static final String DEFAULT_TASK_TAG= "TODO"; //$NON-NLS-1$
/**
* @deprecated Use {@link #DEFAULT_TASK_PRIORITIES} instead.
* @since 2.1
* @category DeprecatedOptionValue
*/
public static final String DEFAULT_TASK_PRIORITY= "NORMAL"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.0
* @category OptionValue
*/
public static final String DEFAULT_TASK_TAGS= "TODO,FIXME,XXX"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.0
* @category OptionValue
*/
public static final String DEFAULT_TASK_PRIORITIES= "NORMAL,HIGH,NORMAL"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String GENERATE= "generate"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String DO_NOT_GENERATE= "do not generate"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String PRESERVE= "preserve"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String OPTIMIZE_OUT= "optimize out"; //$NON-NLS-1$
/**
* Configurable option value for {@link #COMPILER_TASK_PRIORITIES}: {@value}.
*
* @since 2.1
* @category OptionValue
*/
public static final String COMPILER_TASK_PRIORITY_HIGH= "HIGH"; //$NON-NLS-1$
/**
* Configurable option value for {@link #COMPILER_TASK_PRIORITIES}: {@value}.
*
* @since 2.1
* @category OptionValue
*/
public static final String COMPILER_TASK_PRIORITY_LOW= "LOW"; //$NON-NLS-1$
/**
* Configurable option value for {@link #COMPILER_TASK_PRIORITIES}: {@value}.
*
* @since 2.1
* @category OptionValue
*/
public static final String COMPILER_TASK_PRIORITY_NORMAL= "NORMAL"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String VERSION_1_1= "1.1"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String VERSION_1_2= "1.2"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String VERSION_1_3= "1.3"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String VERSION_1_4= "1.4"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.0
* @category OptionValue
*/
public static final String VERSION_1_5= "1.5"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.2
* @category OptionValue
*/
public static final String VERSION_1_6= "1.6"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.3
* @category OptionValue
*/
public static final String VERSION_1_7= "1.7"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.4
* @category OptionValue
*/
public static final String VERSION_CLDC_1_1= "cldc1.1"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String ABORT= "abort"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String ERROR= "error"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String WARNING= "warning"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String IGNORE= "ignore"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @category OptionValue
*/
public static final String COMPUTE= "compute"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String INSERT= "insert"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String DO_NOT_INSERT= "do not insert"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String PRESERVE_ONE= "preserve one"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String CLEAR_ALL= "clear all"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String NORMAL= "normal"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String COMPACT= "compact"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String TAB= "tab"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String SPACE= "space"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String ENABLED= "enabled"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.0
* @category OptionValue
*/
public static final String DISABLED= "disabled"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 2.1
* @category OptionValue
*/
public static final String CLEAN= "clean"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.0
* @category OptionValue
*/
public static final String PUBLIC= "public"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.0
* @category OptionValue
*/
public static final String PROTECTED= "protected"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.0
* @category OptionValue
*/
public static final String DEFAULT= "default"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.0
* @category OptionValue
*/
public static final String PRIVATE= "private"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.1
* @category OptionValue
*/
public static final String NEVER= "never"; //$NON-NLS-1$
/**
* Configurable option value: {@value}.
*
* @since 3.4
* @category OptionValue
*/
public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_NO_TAG= CompilerOptions.NO_TAG;
/**
* Configurable option value: {@value}.
*
* @since 3.4
* @category OptionValue
*/
public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_RETURN_TAG= CompilerOptions.RETURN_TAG;
/**
* Configurable option value: {@value}.
*
* @since 3.4
* @category OptionValue
*/
public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_STANDARD_TAGS= CompilerOptions.ALL_STANDARD_TAGS;
// end configurable option values }
/**
* Value of the content-type for Java source files. Use this value to retrieve the Java content
* type from the content type manager, and to add new Java-like extensions to this content type.
*
* @see org.eclipse.core.runtime.content.IContentTypeManager#getContentType(String)
* @see #getJavaLikeExtensions()
* @since 3.2
*/
public static final String JAVA_SOURCE_CONTENT_TYPE= JavaCore.PLUGIN_ID + ".javaSource"; //$NON-NLS-1$
/**
* Creates the Java core plug-in.
* <p>
* The plug-in instance is created automatically by the Eclipse platform. Clients must not call.
* </p>
*
* @since 3.0
*/
public JavaCore() {
super();
JAVA_CORE_PLUGIN= this;
}
/**
* Adds the given listener for changes to Java elements. Has no effect if an identical listener
* is already registered.
*
* This listener will only be notified during the POST_CHANGE resource change notification and
* any reconcile operation (POST_RECONCILE). For finer control of the notification, use
* <code>addElementChangedListener(IElementChangedListener,int)</code>, which allows to specify
* a different eventMask.
*
* @param listener the listener
* @see ElementChangedEvent
*/
public static void addElementChangedListener(IElementChangedListener listener) {
addElementChangedListener(listener, ElementChangedEvent.POST_CHANGE | ElementChangedEvent.POST_RECONCILE);
}
/**
* Adds the given listener for changes to Java elements. Has no effect if an identical listener
* is already registered. After completion of this method, the given listener will be registered
* for exactly the specified events. If they were previously registered for other events, they
* will be deregistered.
* <p>
* Once registered, a listener starts receiving notification of changes to java elements in the
* model. The listener continues to receive notifications until it is replaced or removed.
* </p>
* <p>
* Listeners can listen for several types of event as defined in <code>ElementChangeEvent</code>
* . Clients are free to register for any number of event types however if they register for
* more than one, it is their responsibility to ensure they correctly handle the case where the
* same java element change shows up in multiple notifications. Clients are guaranteed to
* receive only the events for which they are registered.
* </p>
*
* @param listener the listener
* @param eventMask the bit-wise OR of all event types of interest to the listener
* @see IElementChangedListener
* @see ElementChangedEvent
* @see #removeElementChangedListener(IElementChangedListener)
* @since 2.0
*/
public static void addElementChangedListener(IElementChangedListener listener, int eventMask) {
JavaModelManager.getDeltaState().addElementChangedListener(listener, eventMask);
}
/**
* Configures the given marker attribute map for the given Java element. Used for markers, which
* denote a Java element rather than a resource.
*
* @param attributes the mutable marker attribute map (key type: <code>String</code>, value
* type: <code>String</code>)
* @param element the Java element for which the marker needs to be configured
*/
public static void addJavaElementMarkerAttributes(
Map attributes,
IJavaElement element) {
if (element instanceof IMember)
element= ((IMember)element).getClassFile();
if (attributes != null && element != null)
attributes.put(ATT_HANDLE_ID, element.getHandleIdentifier());
}
private static void addNonJavaResources(Object[] nonJavaResources,
IContainer container,
int rootPathSegmentCounts,
ArrayList collector) {
for (int i= 0, max= nonJavaResources.length; i < max; i++) {
Object nonJavaResource= nonJavaResources[i];
if (nonJavaResource instanceof IFile) {
IFile file= (IFile)nonJavaResource;
IPath path= file.getFullPath().removeFirstSegments(rootPathSegmentCounts);
IResource member= container.findMember(path);
if (member != null && member.exists()) {
collector.add(member);
}
} else if (nonJavaResource instanceof IFolder) {
IFolder folder= (IFolder)nonJavaResource;
IResource[] members= null;
try {
members= folder.members();
} catch (CoreException e) {
// ignore
}
if (members != null) {
addNonJavaResources(members, container, rootPathSegmentCounts, collector);
}
}
}
}
/**
* Adds the given listener for POST_CHANGE resource change events to the Java core. The listener
* is guaranteed to be notified of the POST_CHANGE resource change event before the Java core
* starts processing the resource change event itself.
* <p>
* Has no effect if an identical listener is already registered.
* </p>
*
* @param listener the listener
* @see #removePreProcessingResourceChangedListener(IResourceChangeListener)
* @since 3.0
* @deprecated use addPreProcessingResourceChangedListener(listener,
* IResourceChangeEvent.POST_CHANGE) instead
*/
public static void addPreProcessingResourceChangedListener(IResourceChangeListener listener) {
addPreProcessingResourceChangedListener(listener, IResourceChangeEvent.POST_CHANGE);
}
/**
* Adds the given listener for resource change events of the given types to the Java core. The
* listener is guaranteed to be notified of the resource change event before the Java core
* starts processing the resource change event itself.
* <p>
* If an identical listener is already registered, the given event types are added to the event
* types of interest to the listener.
* </p>
* <p>
* Supported event types are:
* <ul>
* <li>{@link IResourceChangeEvent#PRE_BUILD}</li>
* <li>{@link IResourceChangeEvent#POST_BUILD}</li>
* <li>{@link IResourceChangeEvent#POST_CHANGE}</li>
* <li>{@link IResourceChangeEvent#PRE_DELETE}</li>
* <li>{@link IResourceChangeEvent#PRE_CLOSE}</li>
* </ul>
* This list may increase in the future.
* </p>
*
* @param listener the listener
* @param eventMask the bit-wise OR of all event types of interest to the listener
* @see #removePreProcessingResourceChangedListener(IResourceChangeListener)
* @see IResourceChangeEvent
* @since 3.2
*/
public static void addPreProcessingResourceChangedListener(IResourceChangeListener listener, int eventMask) {
JavaModelManager.getDeltaState().addPreResourceChangedListener(listener, eventMask);
}
/**
* Configures the given marker for the given Java element. Used for markers, which denote a Java
* element rather than a resource.
*
* @param marker the marker to be configured
* @param element the Java element for which the marker needs to be configured
* @exception CoreException if the <code>IMarker.setAttribute</code> on the marker fails
*/
public void configureJavaElementMarker(IMarker marker, IJavaElement element)
throws CoreException {
if (element instanceof IMember)
element= ((IMember)element).getClassFile();
if (marker != null && element != null)
marker.setAttribute(ATT_HANDLE_ID, element.getHandleIdentifier());
}
/**
* Returns the Java model element corresponding to the given handle identifier generated by
* <code>IJavaElement.getHandleIdentifier()</code>, or <code>null</code> if unable to create the
* associated element.
*
* @param handleIdentifier the given handle identifier
* @return the Java element corresponding to the handle identifier
*/
public static IJavaElement create(String handleIdentifier) {
return create(handleIdentifier, DefaultWorkingCopyOwner.PRIMARY);
}
/**
* Returns the Java model element corresponding to the given handle identifier generated by
* <code>IJavaElement.getHandleIdentifier()</code>, or <code>null</code> if unable to create the
* associated element. If the returned Java element is an <code>ICompilationUnit</code> or an
* element inside a compilation unit, the compilation unit's owner is the given owner if such a
* working copy exists, otherwise the compilation unit is a primary compilation unit.
*
* @param handleIdentifier the given handle identifier
* @param owner the owner of the returned compilation unit, ignored if the returned element is
* not a compilation unit, or an element inside a compilation unit
* @return the Java element corresponding to the handle identifier
* @since 3.0
*/
public static IJavaElement create(String handleIdentifier, WorkingCopyOwner owner) {
if (handleIdentifier == null) {
return null;
}
if (owner == null)
owner= DefaultWorkingCopyOwner.PRIMARY;
MementoTokenizer memento= new MementoTokenizer(handleIdentifier);
JavaModel model= JavaModelManager.getJavaModelManager().getJavaModel();
return model.getHandleFromMemento(memento, owner);
}
/**
* Returns the Java element corresponding to the given file, or <code>null</code> if unable to
* associate the given file with a Java element.
*
* <p>
* The file must be one of:
* <ul>
* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions() Java-like extensions} -
* the element returned is the corresponding <code>ICompilationUnit</code></li>
* <li>a <code>.class</code> file - the element returned is the corresponding
* <code>IClassFile</code></li>
* <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element
* returned is the corresponding <code>IPackageFragmentRoot</code></li>
* </ul>
* <p>
* Creating a Java element has the side effect of creating and opening all of the element's
* parents if they are not yet open.
*
* @param file the given file
* @return the Java element corresponding to the given file, or <code>null</code> if unable to
* associate the given file with a Java element
*/
public static IJavaElement create(IFile file) {
return JavaModelManager.create(file, null/*unknown java project*/);
}
/**
* Returns the package fragment or package fragment root corresponding to the given folder, or
* <code>null</code> if unable to associate the given folder with a Java element.
* <p>
* Note that a package fragment root is returned rather than a default package.
* <p>
* Creating a Java element has the side effect of creating and opening all of the element's
* parents if they are not yet open.
*
* @param folder the given folder
* @return the package fragment or package fragment root corresponding to the given folder, or
* <code>null</code> if unable to associate the given folder with a Java element
*/
public static IJavaElement create(IFolder folder) {
return JavaModelManager.create(folder, null/*unknown java project*/);
}
/**
* Returns the Java project corresponding to the given project.
* <p>
* Creating a Java Project has the side effect of creating and opening all of the project's
* parents if they are not yet open.
* <p>
* Note that no check is done at this time on the existence or the java nature of this project.
*
* @param project the given project
* @return the Java project corresponding to the given project, null if the given project is
* null
*/
public static IJavaProject create(IProject project) {
if (project == null) {
return null;
}
JavaModel javaModel= JavaModelManager.getJavaModelManager().getJavaModel();
return javaModel.getJavaProject(project);
}
/**
* Returns the Java element corresponding to the given resource, or <code>null</code> if unable
* to associate the given resource with a Java element.
* <p>
* The resource must be one of:
* <ul>
* <li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions() Java-like extensions} -
* the element returned is the corresponding <code>ICompilationUnit</code></li>
* <li>a <code>.class</code> file - the element returned is the corresponding
* <code>IClassFile</code></li>
* <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element
* returned is the corresponding <code>IPackageFragmentRoot</code></li>
* <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code> or
* <code>IPackageFragment</code></li>
* <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
* </ul>
* <p>
* Creating a Java element has the side effect of creating and opening all of the element's
* parents if they are not yet open.
*
* @param resource the given resource
* @return the Java element corresponding to the given resource, or <code>null</code> if unable
* to associate the given resource with a Java element
*/
public static IJavaElement create(IResource resource) {
return JavaModelManager.create(resource, null/*unknown java project*/);
}
/**
* Returns the Java element corresponding to the given file, its project being the given
* project. Returns <code>null</code> if unable to associate the given resource with a Java
* element.
* <p>
* The resource must be one of:
* <ul>
* <li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions() Java-like extensions} -
* the element returned is the corresponding <code>ICompilationUnit</code></li>
* <li>a <code>.class</code> file - the element returned is the corresponding
* <code>IClassFile</code></li>
* <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element
* returned is the corresponding <code>IPackageFragmentRoot</code></li>
* <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code> or
* <code>IPackageFragment</code></li>
* <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
* </ul>
* <p>
* Creating a Java element has the side effect of creating and opening all of the element's
* parents if they are not yet open.
*
* @param resource the given resource
* @return the Java element corresponding to the given file, or <code>null</code> if unable to
* associate the given file with a Java element
* @since 3.3
*/
public static IJavaElement create(IResource resource, IJavaProject project) {
return JavaModelManager.create(resource, project);
}
/**
* Returns the Java model.
*
* @param root the given root
* @return the Java model, or <code>null</code> if the root is null
*/
public static IJavaModel create(IWorkspaceRoot root) {
if (root == null) {
return null;
}
return JavaModelManager.getJavaModelManager().getJavaModel();
}
/**
* Creates and returns a class file element for the given <code>.class</code> file. Returns
* <code>null</code> if unable to recognize the class file.
*
* @param file the given <code>.class</code> file
* @return a class file element for the given <code>.class</code> file, or <code>null</code> if
* unable to recognize the class file
*/
public static IClassFile createClassFileFrom(IFile file) {
return JavaModelManager.createClassFileFrom(file, null);
}
/**
* Creates and returns a compilation unit element for the given source file (i.e. a file with
* one of the {@link JavaCore#getJavaLikeExtensions() Java-like extensions}). Returns
* <code>null</code> if unable to recognize the compilation unit.
*
* @param file the given source file
* @return a compilation unit element for the given source file, or <code>null</code> if unable
* to recognize the compilation unit
*/
public static ICompilationUnit createCompilationUnitFrom(IFile file) {
return JavaModelManager.createCompilationUnitFrom(file, null/*unknown java project*/);
}
/**
* Creates and returns a handle for the given JAR file. The Java model associated with the JAR's
* project may be created as a side effect.
*
* @param file the given JAR file
* @return a handle for the given JAR file, or <code>null</code> if unable to create a JAR
* package fragment root. (for example, if the JAR file represents a non-Java resource)
*/
public static IPackageFragmentRoot createJarPackageFragmentRootFrom(IFile file) {
return JavaModelManager.createJarPackageFragmentRootFrom(file, null/*unknown java project*/);
}
/**
* Answers the project specific value for a given classpath container. In case this container
* path could not be resolved, then will answer <code>null</code>. Both the container path and
* the project context are supposed to be non-null.
* <p>
* The containerPath is a formed by a first ID segment followed with extra segments, which can
* be used as additional hints for resolution. If no container was ever recorded for this
* container path onto this project (using <code>setClasspathContainer</code>, then a
* <code>ClasspathContainerInitializer</code> will be activated if any was registered for this
* container ID onto the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
* <p>
* There is no assumption that the returned container must answer the exact same containerPath
* when requested <code>IClasspathContainer#getPath</code>. Indeed, the containerPath is just an
* indication for resolving it to an actual container object.
* <p>
* Classpath container values are persisted locally to the workspace, but are not preserved from
* a session to another. It is thus highly recommended to register a
* <code>ClasspathContainerInitializer</code> for each referenced container (through the
* extension point "org.eclipse.jdt.core.ClasspathContainerInitializer").
* <p>
*
* @param containerPath the name of the container, which needs to be resolved
* @param project a specific project in which the container is being resolved
* @return the corresponding classpath container or <code>null</code> if unable to find one.
*
* @exception JavaModelException if an exception occurred while resolving the container, or if
* the resolved container contains illegal entries (contains CPE_CONTAINER
* entries or null entries).
*
* @see ClasspathContainerInitializer
* @see IClasspathContainer
* @see #setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
* @since 2.0
*/
public static IClasspathContainer getClasspathContainer(IPath containerPath, IJavaProject project) throws JavaModelException {
JavaModelManager manager= JavaModelManager.getJavaModelManager();
IClasspathContainer container= manager.getClasspathContainer(containerPath, project);
if (container == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) {
return manager.getPreviousSessionContainer(containerPath, project);
}
return container;
}
/**
* Helper method finding the classpath container initializer registered for a given classpath
* container ID or <code>null</code> if none was found while iterating over the contributions to
* extension point to the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
* <p>
* A containerID is the first segment of any container path, used to identify the registered
* container initializer.
* <p>
*
* @param containerID - a containerID identifying a registered initializer
* @return ClasspathContainerInitializer - the registered classpath container initializer or
* <code>null</code> if none was found.
* @since 2.1
*/
public static ClasspathContainerInitializer getClasspathContainerInitializer(String containerID) {
Hashtable containerInitializersCache= JavaModelManager.getJavaModelManager().containerInitializersCache;
ClasspathContainerInitializer initializer= (ClasspathContainerInitializer)containerInitializersCache.get(containerID);
if (initializer == null) {
initializer= computeClasspathContainerInitializer(containerID);
if (initializer == null)
return null;
containerInitializersCache.put(containerID, initializer);
}
return initializer;
}
private static ClasspathContainerInitializer computeClasspathContainerInitializer(String containerID) {
Plugin jdtCorePlugin= JavaCore.getPlugin();
if (jdtCorePlugin == null)
return null;
IExtensionPoint extension= Platform.getExtensionRegistry().getExtensionPoint(JavaCore.PLUGIN_ID, JavaModelManager.CPCONTAINER_INITIALIZER_EXTPOINT_ID);
if (extension != null) {
IExtension[] extensions= extension.getExtensions();
for (int i= 0; i < extensions.length; i++) {
IConfigurationElement[] configElements= extensions[i].getConfigurationElements();
for (int j= 0; j < configElements.length; j++) {
IConfigurationElement configurationElement= configElements[j];
String initializerID= configurationElement.getAttribute("id"); //$NON-NLS-1$
if (initializerID != null && initializerID.equals(containerID)) {
if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
verbose_found_container_initializer(containerID, configurationElement);
try {
Object execExt= configurationElement.createExecutableExtension("class"); //$NON-NLS-1$
if (execExt instanceof ClasspathContainerInitializer) {
return (ClasspathContainerInitializer)execExt;
}
} catch (CoreException e) {
// executable extension could not be created: ignore this initializer
if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE) {
verbose_failed_to_instanciate_container_initializer(containerID, configurationElement);
e.printStackTrace();
}
}
}
}
}
}
return null;
}
private static void verbose_failed_to_instanciate_container_initializer(String containerID, IConfigurationElement configurationElement) {
Util.verbose(
"CPContainer INIT - failed to instanciate initializer\n" + //$NON-NLS-1$
" container ID: " + containerID + '\n' + //$NON-NLS-1$
" class: " + configurationElement.getAttribute("class"), //$NON-NLS-1$ //$NON-NLS-2$
System.err);
}
private static void verbose_found_container_initializer(String containerID, IConfigurationElement configurationElement) {
Util.verbose(
"CPContainer INIT - found initializer\n" + //$NON-NLS-1$
" container ID: " + containerID + '\n' + //$NON-NLS-1$
" class: " + configurationElement.getAttribute("class")); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* Returns the path held in the given classpath variable. Returns <code>null</code> if unable to
* bind.
* <p>
* Classpath variable values are persisted locally to the workspace, and are preserved from
* session to session.
* <p>
* Note that classpath variables can be contributed registered initializers for, using the
* extension point "org.eclipse.jdt.core.classpathVariableInitializer". If an initializer is
* registered for a variable, its persisted value will be ignored: its initializer will thus get
* the opportunity to rebind the variable differently on each session.
*
* @param variableName the name of the classpath variable
* @return the path, or <code>null</code> if none
* @see #setClasspathVariable(String, IPath)
*/
public static IPath getClasspathVariable(final String variableName) {
JavaModelManager manager= JavaModelManager.getJavaModelManager();
IPath variablePath= manager.variableGet(variableName);
if (variablePath == JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS) {
return manager.getPreviousSessionVariable(variableName);
}
if (variablePath != null) {
if (variablePath == JavaModelManager.CP_ENTRY_IGNORE_PATH)
return null;
return variablePath;
}
// even if persisted value exists, initializer is given priority, only if no initializer is found the persisted value is reused
final ClasspathVariableInitializer initializer= JavaCore.getClasspathVariableInitializer(variableName);
if (initializer != null) {
if (JavaModelManager.CP_RESOLVE_VERBOSE)
verbose_triggering_variable_initialization(variableName, initializer);
if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
verbose_triggering_variable_initialization_invocation_trace();
manager.variablePut(variableName, JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS); // avoid initialization cycles
boolean ok= false;
try {
// let OperationCanceledException go through
// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59363)
initializer.initialize(variableName);
variablePath= manager.variableGet(variableName); // initializer should have performed side-effect
if (variablePath == JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS)
return null; // break cycle (initializer did not init or reentering call)
if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
verbose_variable_value_after_initialization(variableName, variablePath);
manager.variablesWithInitializer.add(variableName);
ok= true;
} catch (RuntimeException e) {
if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE)
e.printStackTrace();
throw e;
} catch (Error e) {
if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE)
e.printStackTrace();
throw e;
} finally {
if (!ok)
JavaModelManager.getJavaModelManager().variablePut(variableName, null); // flush cache
}
} else {
if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE)
verbose_no_variable_initializer_found(variableName);
}
return variablePath;
}
private static void verbose_no_variable_initializer_found(String variableName) {
Util.verbose(
"CPVariable INIT - no initializer found\n" + //$NON-NLS-1$
" variable: " + variableName); //$NON-NLS-1$
}
private static void verbose_variable_value_after_initialization(String variableName, IPath variablePath) {
Util.verbose(
"CPVariable INIT - after initialization\n" + //$NON-NLS-1$
" variable: " + variableName + '\n' + //$NON-NLS-1$
" variable path: " + variablePath); //$NON-NLS-1$
}
private static void verbose_triggering_variable_initialization(String variableName, ClasspathVariableInitializer initializer) {
Util.verbose(
"CPVariable INIT - triggering initialization\n" + //$NON-NLS-1$
" variable: " + variableName + '\n' + //$NON-NLS-1$
" initializer: " + initializer); //$NON-NLS-1$
}
private static void verbose_triggering_variable_initialization_invocation_trace() {
Util.verbose(
"CPVariable INIT - triggering initialization\n" + //$NON-NLS-1$
" invocation trace:"); //$NON-NLS-1$
new Exception("<Fake exception>").printStackTrace(System.out); //$NON-NLS-1$
}
/**
* Returns deprecation message of a given classpath variable.
*
* @param variableName
* @return A string if the classpath variable is deprecated, <code>null</code> otherwise.
* @since 3.3
*/
public static String getClasspathVariableDeprecationMessage(String variableName) {
JavaModelManager manager= JavaModelManager.getJavaModelManager();
// Returns the stored deprecation message
String message= (String)manager.deprecatedVariables.get(variableName);
if (message != null) {
return message;
}
// If the variable has been already initialized, then there's no deprecation message
IPath variablePath= manager.variableGet(variableName);
if (variablePath != null && variablePath != JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS) {
return null;
}
// Search for extension point to get the possible deprecation message
Plugin jdtCorePlugin= JavaCore.getPlugin();
if (jdtCorePlugin == null)
return null;
IExtensionPoint extension= Platform.getExtensionRegistry().getExtensionPoint(JavaCore.PLUGIN_ID, JavaModelManager.CPVARIABLE_INITIALIZER_EXTPOINT_ID);
if (extension != null) {
IExtension[] extensions= extension.getExtensions();
for (int i= 0; i < extensions.length; i++) {
IConfigurationElement[] configElements= extensions[i].getConfigurationElements();
for (int j= 0; j < configElements.length; j++) {
IConfigurationElement configElement= configElements[j];
String varAttribute= configElement.getAttribute("variable"); //$NON-NLS-1$
if (variableName.equals(varAttribute)) {
String deprecatedAttribute= configElement.getAttribute("deprecated"); //$NON-NLS-1$
if (deprecatedAttribute != null) {
return deprecatedAttribute;
}
}
}
}
}
return null;
}
/**
* Helper method finding the classpath variable initializer registered for a given classpath
* variable name or <code>null</code> if none was found while iterating over the contributions
* to extension point to the extension point
* "org.eclipse.jdt.core.classpathVariableInitializer".
* <p>
*
* @param variable the given variable
* @return ClasspathVariableInitializer - the registered classpath variable initializer or
* <code>null</code> if none was found.
* @since 2.1
*/
public static ClasspathVariableInitializer getClasspathVariableInitializer(String variable) {
Plugin jdtCorePlugin= JavaCore.getPlugin();
if (jdtCorePlugin == null)
return null;
IExtensionPoint extension= Platform.getExtensionRegistry().getExtensionPoint(JavaCore.PLUGIN_ID, JavaModelManager.CPVARIABLE_INITIALIZER_EXTPOINT_ID);
if (extension != null) {
IExtension[] extensions= extension.getExtensions();
for (int i= 0; i < extensions.length; i++) {
IConfigurationElement[] configElements= extensions[i].getConfigurationElements();
for (int j= 0; j < configElements.length; j++) {
IConfigurationElement configElement= configElements[j];
try {
String varAttribute= configElement.getAttribute("variable"); //$NON-NLS-1$
if (variable.equals(varAttribute)) {
if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
verbose_found_variable_initializer(variable, configElement);
Object execExt= configElement.createExecutableExtension("class"); //$NON-NLS-1$
if (execExt instanceof ClasspathVariableInitializer) {
ClasspathVariableInitializer initializer= (ClasspathVariableInitializer)execExt;
String deprecatedAttribute= configElement.getAttribute("deprecated"); //$NON-NLS-1$
if (deprecatedAttribute != null) {
JavaModelManager.getJavaModelManager().deprecatedVariables.put(variable, deprecatedAttribute);
}
String readOnlyAttribute= configElement.getAttribute("readOnly"); //$NON-NLS-1$
if (JavaModelManager.TRUE.equals(readOnlyAttribute)) {
JavaModelManager.getJavaModelManager().readOnlyVariables.add(variable);
}
return initializer;
}
}
} catch (CoreException e) {
// executable extension could not be created: ignore this initializer
if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE) {
verbose_failed_to_instanciate_variable_initializer(variable, configElement);
e.printStackTrace();
}
}
}
}
}
return null;
}
private static void verbose_failed_to_instanciate_variable_initializer(String variable, IConfigurationElement configElement) {
Util.verbose(
"CPContainer INIT - failed to instanciate initializer\n" + //$NON-NLS-1$
" variable: " + variable + '\n' + //$NON-NLS-1$
" class: " + configElement.getAttribute("class"), //$NON-NLS-1$ //$NON-NLS-2$
System.err);
}
private static void verbose_found_variable_initializer(String variable, IConfigurationElement configElement) {
Util.verbose(
"CPVariable INIT - found initializer\n" + //$NON-NLS-1$
" variable: " + variable + '\n' + //$NON-NLS-1$
" class: " + configElement.getAttribute("class")); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* Returns the names of all known classpath variables.
* <p>
* Classpath variable values are persisted locally to the workspace, and are preserved from
* session to session.
* <p>
*
* @return the list of classpath variable names
* @see #setClasspathVariable(String, IPath)
*/
public static String[] getClasspathVariableNames() {
return JavaModelManager.getJavaModelManager().variableNames();
}
/**
* Returns a table of all known configurable options with their default values. These options
* allow to configure the behaviour of the underlying components. The client may safely use the
* result as a template that they can modify and then pass to <code>setOptions</code>.
* <p>
* Helper constants have been defined on JavaCore for each of the option IDs (categorized in
* Code assist option ID, Compiler option ID and Core option ID) and some of their acceptable
* values (categorized in Option value). Some options accept open value sets beyond the
* documented constant values.
* <p>
* Note: each release may add new options.
*
* @return a table of all known configurable options with their default values
*/
public static Hashtable getDefaultOptions() {
return JavaModelManager.getJavaModelManager().getDefaultOptions();
}
/**
* Returns the workspace root default charset encoding.
*
* @return the name of the default charset encoding for workspace root.
* @see IContainer#getDefaultCharset()
* @see ResourcesPlugin#getEncoding()
* @since 3.0
*/
public static String getEncoding() {
try {
return ResourcesPlugin.getWorkspace().getRoot().getDefaultCharset();
} catch (IllegalStateException ise) {
// happen when there's no workspace (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=216817)
// or when it is shutting down (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=60687)
return System.getProperty("file.encoding"); //$NON-NLS-1$
} catch (CoreException ce) {
// fails silently and return plugin global encoding if core exception occurs
}
return ResourcesPlugin.getEncoding();
}
/**
* Returns an array that contains the resources generated by the Java builder when building the
* compilation units contained in the given region.
* <p>
* The contents of the array is accurate only if the elements of the given region have been
* built.
* </p>
* <p>
* The given region can contain instances of:
* </p>
* <ul>
* <li><code>org.eclipse.jdt.core.ICompilationUnit</code></li>
* <li><code>org.eclipse.jdt.core.IPackageFragment</code></li>
* <li><code>org.eclipse.jdt.core.IPackageFragmentRoot</code></li>
* <li><code>org.eclipse.jdt.core.IJavaProject</code></li>
* </ul>
* <p>
* All other types of <code>org.eclipse.jdt.core.IJavaElement</code> are ignored.
* </p>
*
* @param region the given region
* @param includesNonJavaResources a flag that indicates if non-java resources should be
* included
*
* @return an array that contains the resources generated by the Java builder when building the
* compilation units contained in the given region, an empty array if none
* @exception IllegalArgumentException if the given region is <code>null</code>
* @since 3.3
*/
public static IResource[] getGeneratedResources(IRegion region, boolean includesNonJavaResources) {
if (region == null)
throw new IllegalArgumentException("region cannot be null"); //$NON-NLS-1$
IJavaElement[] elements= region.getElements();
HashMap projectsStates= new HashMap();
ArrayList collector= new ArrayList();
for (int i= 0, max= elements.length; i < max; i++) {
// collect all the java project
IJavaElement element= elements[i];
IJavaProject javaProject= element.getJavaProject();
IProject project= javaProject.getProject();
State state= null;
State currentState= (State)projectsStates.get(project);
if (currentState != null) {
state= currentState;
} else {
state= (State)JavaModelManager.getJavaModelManager().getLastBuiltState(project, null);
if (state != null) {
projectsStates.put(project, state);
}
}
if (state == null)
continue;
if (element.getElementType() == IJavaElement.JAVA_PROJECT) {
IPackageFragmentRoot[] roots= null;
try {
roots= javaProject.getPackageFragmentRoots();
} catch (JavaModelException e) {
// ignore
}
if (roots == null)
continue;
IRegion region2= JavaCore.newRegion();
for (int j= 0; j < roots.length; j++) {
region2.add(roots[j]);
}
IResource[] res= getGeneratedResources(region2, includesNonJavaResources);
for (int j= 0, max2= res.length; j < max2; j++) {
collector.add(res[j]);
}
continue;
}
IPath outputLocation= null;
try {
outputLocation= javaProject.getOutputLocation();
} catch (JavaModelException e) {
// ignore
}
IJavaElement root= element;
while (root != null && root.getElementType() != IJavaElement.PACKAGE_FRAGMENT_ROOT) {
root= root.getParent();
}
if (root == null)
continue;
IPackageFragmentRoot packageFragmentRoot= (IPackageFragmentRoot)root;
int rootPathSegmentCounts= packageFragmentRoot.getPath().segmentCount();
try {
IClasspathEntry entry= packageFragmentRoot.getRawClasspathEntry();
IPath entryOutputLocation= entry.getOutputLocation();
if (entryOutputLocation != null) {
outputLocation= entryOutputLocation;
}
} catch (JavaModelException e) {
e.printStackTrace();
}
if (outputLocation == null)
continue;
IContainer container= (IContainer)project.getWorkspace().getRoot().findMember(outputLocation);
switch (element.getElementType()) {
case IJavaElement.COMPILATION_UNIT:
// get the .class files generated when this element was built
ICompilationUnit unit= (ICompilationUnit)element;
getGeneratedResource(unit, container, state, rootPathSegmentCounts, collector);
break;
case IJavaElement.PACKAGE_FRAGMENT:
// collect all the .class files generated when all the units in this package were built
IPackageFragment fragment= (IPackageFragment)element;
ICompilationUnit[] compilationUnits= null;
try {
compilationUnits= fragment.getCompilationUnits();
} catch (JavaModelException e) {
// ignore
}
if (compilationUnits == null)
continue;
for (int j= 0, max2= compilationUnits.length; j < max2; j++) {
getGeneratedResource(compilationUnits[j], container, state, rootPathSegmentCounts, collector);
}
if (includesNonJavaResources) {
// retrieve all non-java resources from the output location using the package fragment path
Object[] nonJavaResources= null;
try {
nonJavaResources= fragment.getNonJavaResources();
} catch (JavaModelException e) {
// ignore
}
if (nonJavaResources != null) {
addNonJavaResources(nonJavaResources, container, rootPathSegmentCounts, collector);
}
}
break;
case IJavaElement.PACKAGE_FRAGMENT_ROOT:
// collect all the .class files generated when all the units in this package were built
IPackageFragmentRoot fragmentRoot= (IPackageFragmentRoot)element;
if (fragmentRoot.isArchive())
continue;
IJavaElement[] children= null;
try {
children= fragmentRoot.getChildren();
} catch (JavaModelException e) {
// ignore
}
if (children == null)
continue;
for (int j= 0, max2= children.length; j < max2; j++) {
fragment= (IPackageFragment)children[j];
ICompilationUnit[] units= null;
try {
units= fragment.getCompilationUnits();
} catch (JavaModelException e) {
// ignore
}
if (units == null)
continue;
for (int n= 0, max3= units.length; n < max3; n++) {
getGeneratedResource(units[n], container, state, rootPathSegmentCounts, collector);
}
if (includesNonJavaResources) {
// retrieve all non-java resources from the output location using the package fragment path
Object[] nonJavaResources= null;
try {
nonJavaResources= fragment.getNonJavaResources();
} catch (JavaModelException e) {
// ignore
}
if (nonJavaResources != null) {
addNonJavaResources(nonJavaResources, container, rootPathSegmentCounts, collector);
}
}
}
break;
}
}
int size= collector.size();
if (size != 0) {
IResource[] result= new IResource[size];
collector.toArray(result);
return result;
}
return NO_GENERATED_RESOURCES;
}
private static void getGeneratedResource(ICompilationUnit unit,
IContainer container,
State state,
int rootPathSegmentCounts,
ArrayList collector) {
IResource resource= unit.getResource();
char[][] typeNames= state.getDefinedTypeNamesFor(resource.getProjectRelativePath().toString());
if (typeNames != null) {
IPath path= unit.getPath().removeFirstSegments(rootPathSegmentCounts).removeLastSegments(1);
for (int j= 0, max2= typeNames.length; j < max2; j++) {
IPath localPath= path.append(new String(typeNames[j]) + ".class"); //$NON-NLS-1$
IResource member= container.findMember(localPath);
if (member != null && member.exists()) {
collector.add(member);
}
}
} else {
IPath path= unit.getPath().removeFirstSegments(rootPathSegmentCounts).removeLastSegments(1);
path= path.append(Util.getNameWithoutJavaLikeExtension(unit.getElementName()) + ".class"); //$NON-NLS-1$
IResource member= container.findMember(path);
if (member != null && member.exists()) {
collector.add(member);
}
}
}
/**
* Returns the single instance of the Java core plug-in runtime class. Equivalent to
* <code>(JavaCore) getPlugin()</code>.
*
* @return the single instance of the Java core plug-in runtime class
*/
public static JavaCore getJavaCore() {
return (JavaCore)getPlugin();
}
/**
* Returns the list of known Java-like extensions. Java like extension are defined in the
* {@link org.eclipse.core.runtime.Platform#getContentTypeManager() content type manager} for
* the {@link #JAVA_SOURCE_CONTENT_TYPE}. Note that a Java-like extension doesn't include the
* leading dot ('.'). Also note that the "java" extension is always defined as a Java-like
* extension.
*
* @return the list of known Java-like extensions.
* @since 3.2
*/
public static String[] getJavaLikeExtensions() {
return CharOperation.toStrings(Util.getJavaLikeExtensions());
}
/**
* Helper method for returning one option value only. Equivalent to
* <code>(String)JavaCore.getOptions().get(optionName)</code> Note that it may answer
* <code>null</code> if this option does not exist.
* <p>
* Helper constants have been defined on JavaCore for each of the option IDs (categorized in
* Code assist option ID, Compiler option ID and Core option ID) and some of their acceptable
* values (categorized in Option value). Some options accept open value sets beyond the
* documented constant values.
* <p>
* Note: each release may add new options.
*
* @param optionName the name of an option
* @return the String value of a given option
* @see JavaCore#getDefaultOptions()
* @see JavaCorePreferenceInitializer for changing default settings
* @since 2.0
*/
public static String getOption(String optionName) {
return JavaModelManager.getJavaModelManager().getOption(optionName);
}
/**
* Returns the option that can be used to configure the severity of the compiler problem
* identified by <code>problemID</code> if any, <code>null</code> otherwise. Non-null return
* values are taken from the constants defined by this class whose names start with
* <code>COMPILER_PB</code> and for which the possible values of the option are defined by
* <code>{ "error", "warning", "ignore" }</code>. A null return value means that the provided
* problem ID is unknown or that it matches a problem whose severity cannot be configured.
*
* @param problemID one of the problem IDs defined by {@link IProblem}
* @return the option that can be used to configure the severity of the compiler problem
* identified by <code>problemID</code> if any, <code>null</code> otherwise
* @since 3.4
*/
public static String getOptionForConfigurableSeverity(int problemID) {
return CompilerOptions.optionKeyFromIrritant(ProblemReporter.getIrritant(problemID));
}
/**
* Returns the table of the current options. Initially, all options have their default values,
* and this method returns a table that includes all known options.
* <p>
* Helper constants have been defined on JavaCore for each of the option IDs (categorized in
* Code assist option ID, Compiler option ID and Core option ID) and some of their acceptable
* values (categorized in Option value). Some options accept open value sets beyond the
* documented constant values.
* <p>
* Note: each release may add new options.
* <p>
* Returns a default set of options even if the platform is not running.
* </p>
*
* @return table of current settings of all options (key type: <code>String</code>; value type:
* <code>String</code>)
* @see #getDefaultOptions()
* @see JavaCorePreferenceInitializer for changing default settings
*/
public static Hashtable getOptions() {
return JavaModelManager.getJavaModelManager().getOptions();
}
/**
* Returns the single instance of the Java core plug-in runtime class.
*
* @return the single instance of the Java core plug-in runtime class
*/
public static Plugin getPlugin() {
return JAVA_CORE_PLUGIN;
}
/**
* This is a helper method, which returns the resolved classpath entry denoted by a given entry
* (if it is a variable entry). It is obtained by resolving the variable reference in the first
* segment. Returns <code>null</code> if unable to resolve using the following algorithm:
* <ul>
* <li>if variable segment cannot be resolved, returns <code>null</code></li>
* <li>finds a project, JAR or binary folder in the workspace at the resolved path location</li>
* <li>if none finds an external JAR file or folder outside the workspace at the resolved path
* location</li>
* <li>if none returns <code>null</code></li>
* </ul>
* <p>
* Variable source attachment path and root path are also resolved and recorded in the resulting
* classpath entry.
* <p>
* NOTE: This helper method does not handle classpath containers, for which should rather be
* used <code>JavaCore#getClasspathContainer(IPath, IJavaProject)</code>.
* <p>
*
* @param entry the given variable entry
* @return the resolved library or project classpath entry, or <code>null</code> if the given
* variable entry could not be resolved to a valid classpath entry
*/
public static IClasspathEntry getResolvedClasspathEntry(IClasspathEntry entry) {
return JavaModelManager.getJavaModelManager().resolveVariableEntry(entry, false/*don't use previous session value*/);
}
/**
* Resolve a variable path (helper method).
*
* @param variablePath the given variable path
* @return the resolved variable path or <code>null</code> if none
*/
public static IPath getResolvedVariablePath(IPath variablePath) {
return JavaModelManager.getJavaModelManager().getResolvedVariablePath(variablePath, false/*don't use previous session value*/);
}
/**
* Answers the shared working copies currently registered for this buffer factory. Working
* copies can be shared by several clients using the same buffer factory,see
* <code>IWorkingCopy.getSharedWorkingCopy</code>.
*
* @param factory the given buffer factory
* @return the list of shared working copies for a given buffer factory
* @since 2.0
* @deprecated Use {@link #getWorkingCopies(WorkingCopyOwner)} instead
*/
public static IWorkingCopy[] getSharedWorkingCopies(IBufferFactory factory) {
// if factory is null, default factory must be used
if (factory == null)
factory= BufferManager.getDefaultBufferManager().getDefaultBufferFactory();
return getWorkingCopies(BufferFactoryWrapper.create(factory));
}
/**
* Returns the names of all defined user libraries. The corresponding classpath container path
* is the name appended to the USER_LIBRARY_CONTAINER_ID.
*
* @return Return an array containing the names of all known user defined.
* @since 3.0
*/
public static String[] getUserLibraryNames() {
return JavaModelManager.getUserLibraryManager().getUserLibraryNames();
}
/**
* Returns the working copies that have the given owner. Only compilation units in working copy
* mode are returned. If the owner is <code>null</code>, primary working copies are returned.
*
* @param owner the given working copy owner or <code>null</code> for primary working copy owner
* @return the list of working copies for a given owner
* @since 3.0
*/
public static ICompilationUnit[] getWorkingCopies(WorkingCopyOwner owner) {
JavaModelManager manager= JavaModelManager.getJavaModelManager();
if (owner == null)
owner= DefaultWorkingCopyOwner.PRIMARY;
ICompilationUnit[] result= manager.getWorkingCopies(owner, false/*don't add primary WCs*/);
if (result == null)
return JavaModelManager.NO_WORKING_COPY;
return result;
}
/**
* Initializes JavaCore internal structures to allow subsequent operations (such as the ones
* that need a resolved classpath) to run full speed. A client may choose to call this method in
* a background thread early after the workspace has started so that the initialization is
* transparent to the user.
* <p>
* However calling this method is optional. Services will lazily perform initialization when
* invoked. This is only a way to reduce initialization overhead on user actions, if it can be
* performed before at some appropriate moment.
* </p>
* <p>
* This initialization runs accross all Java projects in the workspace. Thus the workspace root
* scheduling rule is used during this operation.
* </p>
* <p>
* This method may return before the initialization is complete. The initialization will then
* continue in a background thread.
* </p>
* <p>
* This method can be called concurrently.
* </p>
*
* @param monitor a progress monitor, or <code>null</code> if progress reporting and
* cancellation are not desired
* @exception CoreException if the initialization fails, the status of the exception indicates
* the reason of the failure
* @since 3.1
*/
public static void initializeAfterLoad(IProgressMonitor monitor) throws CoreException {
try {
if (monitor != null) {
monitor.beginTask(Messages.javamodel_initialization, 100);
monitor.subTask(Messages.javamodel_configuring_classpath_containers);
}
// initialize all containers and variables
JavaModelManager manager= JavaModelManager.getJavaModelManager();
SubProgressMonitor subMonitor= null;
try {
if (monitor != null) {
subMonitor= new SubProgressMonitor(monitor, 50); // 50% of the time is spent in initializing containers and variables
subMonitor.beginTask("", 100); //$NON-NLS-1$
subMonitor.worked(5); // give feedback to the user that something is happening
manager.batchContainerInitializationsProgress.initializeAfterLoadMonitor.set(subMonitor);
}
if (manager.forceBatchInitializations(true/*initAfterLoad*/)) { // if no other thread has started the batch container initializations
manager.getClasspathContainer(Path.EMPTY, null); // force the batch initialization
} else { // else wait for the batch initialization to finish
while (manager.batchContainerInitializations == JavaModelManager.BATCH_INITIALIZATION_IN_PROGRESS) {
if (subMonitor != null) {
subMonitor.subTask(manager.batchContainerInitializationsProgress.subTaskName);
subMonitor.worked(manager.batchContainerInitializationsProgress.getWorked());
}
synchronized (manager) {
try {
manager.wait(100);
} catch (InterruptedException e) {
// continue
}
}
}
}
} finally {
if (subMonitor != null)
subMonitor.done();
manager.batchContainerInitializationsProgress.initializeAfterLoadMonitor.set(null);
}
// avoid leaking source attachment properties (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=183413 )
// and recreate links for external folders if needed
if (monitor != null)
monitor.subTask(Messages.javamodel_resetting_source_attachment_properties);
ExternalFoldersManager externalFoldersManager= JavaModelManager.getExternalManager();
final IJavaProject[] projects= manager.getJavaModel().getJavaProjects();
HashSet visitedPaths= new HashSet();
for (int i= 0, length= projects.length; i < length; i++) {
JavaProject javaProject= (JavaProject)projects[i];
IClasspathEntry[] classpath;
try {
classpath= javaProject.getResolvedClasspath();
} catch (JavaModelException e) {
// project no longer exist: ignore
continue;
}
if (classpath != null) {
boolean needExternalFolderCreation= false;
for (int j= 0, length2= classpath.length; j < length2; j++) {
IClasspathEntry entry= classpath[j];
if (entry.getSourceAttachmentPath() != null) {
IPath entryPath= entry.getPath();
if (visitedPaths.add(entryPath)) {
Util.setSourceAttachmentProperty(entryPath, null);
}
}
// else source might have been attached by IPackageFragmentRoot#attachSource(...), we keep it
if (!needExternalFolderCreation && entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
IPath entryPath= entry.getPath();
if (ExternalFoldersManager.isExternalFolderPath(entryPath) && externalFoldersManager.getFolder(entryPath) == null) {
needExternalFolderCreation= true;
}
}
}
if (needExternalFolderCreation)
manager.deltaState.addExternalFolderChange(javaProject, null/*act as if all external folders were new*/);
}
}
// initialize delta state
if (monitor != null)
monitor.subTask(Messages.javamodel_initializing_delta_state);
manager.deltaState.rootsAreStale= true; // in case it was already initialized before we cleaned up the source attachment proprties
manager.deltaState.initializeRoots(true/*initAfteLoad*/);
// dummy query for waiting until the indexes are ready
if (monitor != null)
monitor.subTask(Messages.javamodel_configuring_searchengine);
SearchEngine engine= new SearchEngine();
IJavaSearchScope scope= SearchEngine.createWorkspaceScope();
try {
engine.searchAllTypeNames(
null,
SearchPattern.R_EXACT_MATCH, "!@$#!@".toCharArray(), //$NON-NLS-1$
SearchPattern.R_PATTERN_MATCH | SearchPattern.R_CASE_SENSITIVE,
IJavaSearchConstants.CLASS,
scope,
new TypeNameRequestor() {
public void acceptType(
int modifiers,
char[] packageName,
char[] simpleTypeName,
char[][] enclosingTypeNames,
String path) {
// no type to accept
}
},
// will not activate index query caches if indexes are not ready, since it would take to long
// to wait until indexes are fully rebuild
IJavaSearchConstants.CANCEL_IF_NOT_READY_TO_SEARCH,
monitor == null ? null : new SubProgressMonitor(monitor, 49) // 49% of the time is spent in the dummy search
);
} catch (JavaModelException e) {
// /search failed: ignore
} catch (OperationCanceledException e) {
if (monitor != null && monitor.isCanceled())
throw e;
// else indexes were not ready: catch the exception so that jars are still refreshed
}
// check if the build state version number has changed since last session
// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=98969)
if (monitor != null)
monitor.subTask(Messages.javamodel_getting_build_state_number);
QualifiedName qName= new QualifiedName(JavaCore.PLUGIN_ID, "stateVersionNumber"); //$NON-NLS-1$
IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
String versionNumber= null;
try {
versionNumber= root.getPersistentProperty(qName);
} catch (CoreException e) {
// could not read version number: consider it is new
}
final JavaModel model= manager.getJavaModel();
String newVersionNumber= Byte.toString(State.VERSION);
if (!newVersionNumber.equals(versionNumber)) {
// build state version number has changed: touch every projects to force a rebuild
if (JavaBuilder.DEBUG)
System.out.println("Build state version number has changed"); //$NON-NLS-1$
IWorkspaceRunnable runnable= new IWorkspaceRunnable() {
public void run(IProgressMonitor progressMonitor2) throws CoreException {
for (int i= 0, length= projects.length; i < length; i++) {
IJavaProject project= projects[i];
try {
if (JavaBuilder.DEBUG)
System.out.println("Touching " + project.getElementName()); //$NON-NLS-1$
project.getProject().touch(progressMonitor2);
} catch (CoreException e) {
// could not touch this project: ignore
}
}
}
};
if (monitor != null)
monitor.subTask(Messages.javamodel_building_after_upgrade);
try {
ResourcesPlugin.getWorkspace().run(runnable, monitor);
} catch (CoreException e) {
// could not touch all projects
}
try {
root.setPersistentProperty(qName, newVersionNumber);
} catch (CoreException e) {
Util.log(e, "Could not persist build state version number"); //$NON-NLS-1$
}
}
// ensure external jars are refreshed (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=93668)
try {
if (monitor != null)
monitor.subTask(Messages.javamodel_refreshing_external_jars);
model.refreshExternalArchives(
null/*refresh all projects*/,
monitor == null ? null : new SubProgressMonitor(monitor, 1) // 1% of the time is spent in jar refresh
);
} catch (JavaModelException e) {
// refreshing failed: ignore
}
} finally {
if (monitor != null)
monitor.done();
}
}
/**
* Returns whether a given classpath variable is read-only or not.
*
* @param variableName
* @return <code>true</code> if the classpath variable is read-only, <code>false</code>
* otherwise.
* @since 3.3
*/
public static boolean isClasspathVariableReadOnly(String variableName) {
return JavaModelManager.getJavaModelManager().readOnlyVariables.contains(variableName);
}
/**
* Returns whether the given file name's extension is a Java-like extension.
*
* @return whether the given file name's extension is a Java-like extension
* @see #getJavaLikeExtensions()
* @since 3.2
*/
public static boolean isJavaLikeFileName(String fileName) {
return Util.isJavaLikeFileName(fileName);
}
/**
* Returns whether the given marker references the given Java element. Used for markers, which
* denote a Java element rather than a resource.
*
* @param element the element
* @param marker the marker
* @return <code>true</code> if the marker references the element, false otherwise
* @exception CoreException if the <code>IMarker.getAttribute</code> on the marker fails
*/
public static boolean isReferencedBy(IJavaElement element, IMarker marker) throws CoreException {
// only match units or classfiles
if (element instanceof IMember) {
IMember member= (IMember)element;
if (member.isBinary()) {
element= member.getClassFile();
} else {
element= member.getCompilationUnit();
}
}
if (element == null)
return false;
if (marker == null)
return false;
String markerHandleId= (String)marker.getAttribute(ATT_HANDLE_ID);
if (markerHandleId == null)
return false;
IJavaElement markerElement= JavaCore.create(markerHandleId);
while (true) {
if (element.equals(markerElement))
return true; // external elements may still be equal with different handleIDs.
// cycle through enclosing types in case marker is associated with a classfile (15568)
if (markerElement instanceof IClassFile) {
IType enclosingType= ((IClassFile)markerElement).getType().getDeclaringType();
if (enclosingType != null) {
markerElement= enclosingType.getClassFile(); // retry with immediate enclosing classfile
continue;
}
}
break;
}
return false;
}
/**
* Returns whether the given marker delta references the given Java element. Used for markers
* deltas, which denote a Java element rather than a resource.
*
* @param element the element
* @param markerDelta the marker delta
* @return <code>true</code> if the marker delta references the element
* @exception CoreException if the <code>IMarkerDelta.getAttribute</code> on the marker delta
* fails
*/
public static boolean isReferencedBy(IJavaElement element, IMarkerDelta markerDelta) throws CoreException {
// only match units or classfiles
if (element instanceof IMember) {
IMember member= (IMember)element;
if (member.isBinary()) {
element= member.getClassFile();
} else {
element= member.getCompilationUnit();
}
}
if (element == null)
return false;
if (markerDelta == null)
return false;
String markerDeltarHandleId= (String)markerDelta.getAttribute(ATT_HANDLE_ID);
if (markerDeltarHandleId == null)
return false;
IJavaElement markerElement= JavaCore.create(markerDeltarHandleId);
while (true) {
if (element.equals(markerElement))
return true; // external elements may still be equal with different handleIDs.
// cycle through enclosing types in case marker is associated with a classfile (15568)
if (markerElement instanceof IClassFile) {
IType enclosingType= ((IClassFile)markerElement).getType().getDeclaringType();
if (enclosingType != null) {
markerElement= enclosingType.getClassFile(); // retry with immediate enclosing classfile
continue;
}
}
break;
}
return false;
}
/**
* Creates and returns a new access rule with the given file pattern and kind.
* <p>
* The rule kind is one of {@link IAccessRule#K_ACCESSIBLE}, {@link IAccessRule#K_DISCOURAGED},
* or {@link IAccessRule#K_NON_ACCESSIBLE}, optionally combined with
* {@link IAccessRule#IGNORE_IF_BETTER}, e..g.
* <code>IAccessRule.K_NON_ACCESSIBLE | IAccessRule.IGNORE_IF_BETTER</code>.
* </p>
*
* @param filePattern the file pattern this access rule should match
* @param kind one of {@link IAccessRule#K_ACCESSIBLE}, {@link IAccessRule#K_DISCOURAGED}, or
* {@link IAccessRule#K_NON_ACCESSIBLE}, optionally combined with
* {@link IAccessRule#IGNORE_IF_BETTER}
* @return a new access rule
* @since 3.1
*/
public static IAccessRule newAccessRule(IPath filePattern, int kind) {
return new ClasspathAccessRule(filePattern, kind);
}
/**
* Creates and returns a new classpath attribute with the given name and the given value.
*
* @return a new classpath attribute
* @since 3.1
*/
public static IClasspathAttribute newClasspathAttribute(String name, String value) {
return new ClasspathAttribute(name, value);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code> for the given
* path. This method is fully equivalent to calling
* {@link #newContainerEntry(IPath, IAccessRule[], IClasspathAttribute[], boolean)
* newContainerEntry(containerPath, new IAccessRule[0], new IClasspathAttribute[0], false)}.
* <p>
*
* @param containerPath the path identifying the container, it must be formed of two segments
* @return a new container classpath entry
*
* @see JavaCore#getClasspathContainer(IPath, IJavaProject)
* @since 2.0
*/
public static IClasspathEntry newContainerEntry(IPath containerPath) {
return newContainerEntry(
containerPath,
ClasspathEntry.NO_ACCESS_RULES,
ClasspathEntry.NO_EXTRA_ATTRIBUTES,
false/*not exported*/);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code> for the given
* path. This method is fully equivalent to calling
* {@link #newContainerEntry(IPath, IAccessRule[], IClasspathAttribute[], boolean)
* newContainerEntry(containerPath, new IAccessRule[0], new IClasspathAttribute[0], isExported)}
* .
*
* @param containerPath the path identifying the container, it must be formed of at least one
* segment (ID+hints)
* @param isExported a boolean indicating whether this entry is contributed to dependent
* projects in addition to the output location
* @return a new container classpath entry
*
* @see JavaCore#getClasspathContainer(IPath, IJavaProject)
* @see JavaCore#setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[],
* IProgressMonitor)
* @since 2.0
*/
public static IClasspathEntry newContainerEntry(IPath containerPath, boolean isExported) {
return newContainerEntry(
containerPath,
ClasspathEntry.NO_ACCESS_RULES,
ClasspathEntry.NO_EXTRA_ATTRIBUTES,
isExported);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code> for the given
* path. The path of the container will be used during resolution so as to map this container
* entry to a set of other classpath entries the container is acting for.
* <p>
* A container entry allows to express indirect references to a set of libraries, projects and
* variable entries, which can be interpreted differently for each Java project where it is
* used. A classpath container entry can be resolved using
* <code>JavaCore.getResolvedClasspathContainer</code>, and updated with
* <code>JavaCore.classpathContainerChanged</code>
* <p>
* A container is exclusively resolved by a <code>ClasspathContainerInitializer</code>
* registered onto the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
* <p>
* A container path must be formed of at least one segment, where:
* <ul>
* <li>the first segment is a unique ID identifying the target container, there must be a
* container initializer registered onto this ID through the extension point
* "org.eclipse.jdt.core.classpathContainerInitializer".</li>
* <li>the remaining segments will be passed onto the initializer, and can be used as additional
* hints during the initialization phase.</li>
* </ul>
* <p>
* Example of an ClasspathContainerInitializer for a classpath container denoting a default JDK
* container:
*
* <pre>
* containerEntry = JavaCore.newContainerEntry(new Path("MyProvidedJDK/default"));
*
* <extension
* point="org.eclipse.jdt.core.classpathContainerInitializer">
* <containerInitializer
* id="MyProvidedJDK"
* class="com.example.MyInitializer"/>
* </pre>
* <p>
* The access rules determine the set of accessible source and class files in the container. If
* the list of access rules is empty, then all files in this container are accessible. See
* {@link IAccessRule} for a detailed description of access rules. Note that if an entry defined
* by the container defines access rules, then these access rules are combined with the given
* access rules. The given access rules are considered first, then the entry's access rules are
* considered.
* </p>
* <p>
* The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
* this entry. If no extra attributes are provided, an empty array must be passed in.<br>
* Note that this list should not contain any duplicate name.
* </p>
* <p>
* The <code>isExported</code> flag indicates whether this entry is contributed to dependent
* projects. If not exported, dependent projects will not see any of the classes from this
* entry. If exported, dependent projects will concatenate the accessible files patterns of this
* entry with the accessible files patterns of the projects, and they will concatenate the non
* accessible files patterns of this entry with the non accessible files patterns of the
* project.
* </p>
* <p>
* Note that this operation does not attempt to validate classpath containers or access the
* resources at the given paths.
* </p>
*
* @param containerPath the path identifying the container, it must be formed of at least one
* segment (ID+hints)
* @param accessRules the possibly empty list of access rules for this entry
* @param extraAttributes the possibly empty list of extra attributes to persist with this entry
* @param isExported a boolean indicating whether this entry is contributed to dependent
* projects in addition to the output location
* @return a new container classpath entry
*
* @see JavaCore#getClasspathContainer(IPath, IJavaProject)
* @see JavaCore#setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[],
* IProgressMonitor)
* @see JavaCore#newContainerEntry(IPath, boolean)
* @see JavaCore#newAccessRule(IPath, int)
* @since 3.1
*/
public static IClasspathEntry newContainerEntry(
IPath containerPath,
IAccessRule[] accessRules,
IClasspathAttribute[] extraAttributes,
boolean isExported) {
if (containerPath == null) {
throw new ClasspathEntry.AssertionFailedException("Container path cannot be null"); //$NON-NLS-1$
} else if (containerPath.segmentCount() < 1) {
throw new ClasspathEntry.AssertionFailedException(
"Illegal classpath container path: \'" + containerPath.makeRelative().toString() + "\', must have at least one segment (containerID+hints)"); //$NON-NLS-1$//$NON-NLS-2$
}
if (accessRules == null) {
accessRules= ClasspathEntry.NO_ACCESS_RULES;
}
if (extraAttributes == null) {
extraAttributes= ClasspathEntry.NO_EXTRA_ATTRIBUTES;
}
return new ClasspathEntry(
IPackageFragmentRoot.K_SOURCE,
IClasspathEntry.CPE_CONTAINER,
containerPath,
ClasspathEntry.INCLUDE_ALL, // inclusion patterns
ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
null, // source attachment
null, // source attachment root
null, // specific output folder
isExported,
accessRules,
true, // combine access rules
extraAttributes);
}
/**
* Creates and returns a type hierarchy for all types in the given region, considering subtypes
* within that region and considering types in the working copies with the given owner. In other
* words, the owner's working copies will take precedence over their original compilation units
* in the workspace.
* <p>
* Note that if a working copy is empty, it will be as if the original compilation unit had been
* deleted.
* <p>
*
* @param monitor the given progress monitor
* @param region the given region
* @param owner the owner of working copies that take precedence over their original compilation
* units, or <code>null</code> if the primary working copy owner should be used
* @exception JavaModelException if an element in the region does not exist or if an exception
* occurs while accessing its corresponding resource
* @exception IllegalArgumentException if region is <code>null</code>
* @return a type hierarchy for all types in the given region, considering subtypes within that
* region
* @since 3.1
*/
public static ITypeHierarchy newTypeHierarchy(IRegion region, WorkingCopyOwner owner, IProgressMonitor monitor) throws JavaModelException {
if (region == null) {
throw new IllegalArgumentException(Messages.hierarchy_nullRegion);
}
ICompilationUnit[] workingCopies= JavaModelManager.getJavaModelManager().getWorkingCopies(owner, true/*add primary working copies*/);
CreateTypeHierarchyOperation op=
new CreateTypeHierarchyOperation(region, workingCopies, null, true/*compute subtypes*/);
op.runOperation(monitor);
return op.getResult();
}
/**
* Creates and returns a new non-exported classpath entry of kind <code>CPE_LIBRARY</code> for
* the JAR or folder identified by the given absolute path. This specifies that all package
* fragments within the root will have children of type <code>IClassFile</code>. This method is
* fully equivalent to calling
* {@link #newLibraryEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
* newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new
* IClasspathAttribute[0], false)}.
*
* @param path the path to the library
* @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
* or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote
* no source attachment. Since 3.4, this path can also denote a path external to the
* workspace. and will be automatically converted to <code>null</code>.
* @param sourceAttachmentRootPath the location of the root of the source files within the
* source archive or folder or <code>null</code> if this location should be
* automatically detected.
* @return a new library classpath entry
*/
public static IClasspathEntry newLibraryEntry(
IPath path,
IPath sourceAttachmentPath,
IPath sourceAttachmentRootPath) {
return newLibraryEntry(
path,
sourceAttachmentPath,
sourceAttachmentRootPath,
ClasspathEntry.NO_ACCESS_RULES,
ClasspathEntry.NO_EXTRA_ATTRIBUTES,
false/*not exported*/);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_LIBRARY</code> for the JAR or
* folder identified by the given absolute path. This specifies that all package fragments
* within the root will have children of type <code>IClassFile</code>. This method is fully
* equivalent to calling
* {@link #newLibraryEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
* newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new
* IClasspathAttribute[0], isExported)}.
*
* @param path the path to the library
* @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
* or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote
* no source attachment. and will be automatically converted to <code>null</code>.
* Since 3.4, this path can also denote a path external to the workspace.
* @param sourceAttachmentRootPath the location of the root of the source files within the
* source archive or folder or <code>null</code> if this location should be
* automatically detected.
* @param isExported indicates whether this entry is contributed to dependent projects in
* addition to the output location
* @return a new library classpath entry
* @since 2.0
*/
public static IClasspathEntry newLibraryEntry(
IPath path,
IPath sourceAttachmentPath,
IPath sourceAttachmentRootPath,
boolean isExported) {
return newLibraryEntry(
path,
sourceAttachmentPath,
sourceAttachmentRootPath,
ClasspathEntry.NO_ACCESS_RULES,
ClasspathEntry.NO_EXTRA_ATTRIBUTES,
isExported);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_LIBRARY</code> for the JAR or
* folder identified by the given absolute path. This specifies that all package fragments
* within the root will have children of type <code>IClassFile</code>.
* <p>
* A library entry is used to denote a prerequisite JAR or root folder containing binaries. The
* target JAR can either be defined internally to the workspace (absolute path relative to the
* workspace root), or externally to the workspace (absolute path in the file system). The
* target root folder can also be defined internally to the workspace (absolute path relative to
* the workspace root), or - since 3.4 - externally to the workspace (absolute path in the file
* system). Since 3.5, the path to the library can also be relative to the project using ".." as
* the first segment.
* <p>
* e.g. Here are some examples of binary path usage
* <ul>
* <li><code> "c:\jdk1.2.2\jre\lib\rt.jar" </code> - reference to an external JAR on Windows</li>
* <li><code> "/Project/someLib.jar" </code> - reference to an internal JAR on Windows or Linux</li>
* <li><code> "/Project/classes/" </code> - reference to an internal binary folder on Windows or
* Linux</li>
* <li><code> "/home/usr/classes" </code> - reference to an external binary folder on Linux</li>
* <li><code> "../../lib/someLib.jar" </code> - reference to an external JAR that is a sibbling
* of the workspace on either platform</li>
* </ul>
* Note that on non-Windows platform, a path <code>"/some/lib.jar"</code> is ambiguous. It can
* be a path to an external JAR (its file system path being <code>"/some/lib.jar"</code>) or it
* can be a path to an internal JAR (<code>"some"</code> being a project in the workspace). Such
* an ambiguity is solved when the classpath entry is used (e.g. in
* {@link IJavaProject#getPackageFragmentRoots()}). If the resource <code>"lib.jar"</code>
* exists in project <code>"some"</code>, then it is considered an internal JAR. Otherwise it is
* an external JAR.
* <p>
* Also note that this operation does not attempt to validate or access the resources at the
* given paths.
* </p>
* <p>
* The access rules determine the set of accessible class files in the library. If the list of
* access rules is empty then all files in this library are accessible. See {@link IAccessRule}
* for a detailed description of access rules.
* </p>
* <p>
* The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
* this entry. If no extra attributes are provided, an empty array must be passed in.<br>
* Note that this list should not contain any duplicate name.
* </p>
* <p>
* The <code>isExported</code> flag indicates whether this entry is contributed to dependent
* projects. If not exported, dependent projects will not see any of the classes from this
* entry. If exported, dependent projects will concatenate the accessible files patterns of this
* entry with the accessible files patterns of the projects, and they will concatenate the non
* accessible files patterns of this entry with the non accessible files patterns of the
* project.
* </p>
* <p>
* Since 3.5, if the libray is a ZIP archive, the "Class-Path" clause (if any) in the
* "META-INF/MANIFEST.MF" is read and referenced ZIP archives are added to the
* {@link IJavaProject#getResolvedClasspath(boolean) resolved classpath}.
* </p>
*
* @param path the path to the library
* @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
* or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote
* no source attachment. and will be automatically converted to <code>null</code>.
* Since 3.4, this path can also denote a path external to the workspace.
* @param sourceAttachmentRootPath the location of the root of the source files within the
* source archive or folder or <code>null</code> if this location should be
* automatically detected.
* @param accessRules the possibly empty list of access rules for this entry
* @param extraAttributes the possibly empty list of extra attributes to persist with this entry
* @param isExported indicates whether this entry is contributed to dependent projects in
* addition to the output location
* @return a new library classpath entry
* @since 3.1
*/
public static IClasspathEntry newLibraryEntry(
IPath path,
IPath sourceAttachmentPath,
IPath sourceAttachmentRootPath,
IAccessRule[] accessRules,
IClasspathAttribute[] extraAttributes,
boolean isExported) {
if (path == null)
throw new ClasspathEntry.AssertionFailedException("Library path cannot be null"); //$NON-NLS-1$
if (accessRules == null) {
accessRules= ClasspathEntry.NO_ACCESS_RULES;
}
if (extraAttributes == null) {
extraAttributes= ClasspathEntry.NO_EXTRA_ATTRIBUTES;
}
boolean hasDotDot= ClasspathEntry.hasDotDot(path);
if (!hasDotDot && !path.isAbsolute())
throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute: " + path); //$NON-NLS-1$
if (sourceAttachmentPath != null) {
if (sourceAttachmentPath.isEmpty()) {
sourceAttachmentPath= null; // treat empty path as none
} else if (!sourceAttachmentPath.isAbsolute()) {
throw new ClasspathEntry.AssertionFailedException("Source attachment path '" //$NON-NLS-1$
+ sourceAttachmentPath
+ "' for IClasspathEntry must be absolute"); //$NON-NLS-1$
}
}
return new ClasspathEntry(
IPackageFragmentRoot.K_BINARY,
IClasspathEntry.CPE_LIBRARY,
hasDotDot ? path : JavaProject.canonicalizedPath(path),
ClasspathEntry.INCLUDE_ALL, // inclusion patterns
ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
sourceAttachmentPath,
sourceAttachmentRootPath,
null, // specific output folder
isExported,
accessRules,
false, // no access rules to combine
extraAttributes);
}
/**
* Creates and returns a new non-exported classpath entry of kind <code>CPE_PROJECT</code> for
* the project identified by the given absolute path. This method is fully equivalent to calling
* {@link #newProjectEntry(IPath, IAccessRule[], boolean, IClasspathAttribute[], boolean)
* newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], false)}.
*
* @param path the absolute path of the binary archive
* @return a new project classpath entry
*/
public static IClasspathEntry newProjectEntry(IPath path) {
return newProjectEntry(path, false);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_PROJECT</code> for the project
* identified by the given absolute path. This method is fully equivalent to calling
* {@link #newProjectEntry(IPath, IAccessRule[], boolean, IClasspathAttribute[], boolean)
* newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], isExported)}.
*
* @param path the absolute path of the prerequisite project
* @param isExported indicates whether this entry is contributed to dependent projects in
* addition to the output location
* @return a new project classpath entry
* @since 2.0
*/
public static IClasspathEntry newProjectEntry(IPath path, boolean isExported) {
if (!path.isAbsolute())
throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
return newProjectEntry(
path,
ClasspathEntry.NO_ACCESS_RULES,
true,
ClasspathEntry.NO_EXTRA_ATTRIBUTES,
isExported);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_PROJECT</code> for the project
* identified by the given absolute path.
* <p>
* A project entry is used to denote a prerequisite project on a classpath. The referenced
* project will be contributed as a whole, either as sources (in the Java Model, it contributes
* all its package fragment roots) or as binaries (when building, it contributes its whole
* output location).
* </p>
* <p>
* A project reference allows to indirect through another project, independently from its
* internal layout.
* </p>
* <p>
* The prerequisite project is referred to using an absolute path relative to the workspace
* root.
* </p>
* <p>
* The access rules determine the set of accessible class files in the project. If the list of
* access rules is empty then all files in this project are accessible. See {@link IAccessRule}
* for a detailed description of access rules.
* </p>
* <p>
* The <code>combineAccessRules</code> flag indicates whether access rules of one (or more)
* exported entry of the project should be combined with the given access rules. If they should
* be combined, the given access rules are considered first, then the entry's access rules are
* considered.
* </p>
* <p>
* The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
* this entry. If no extra attributes are provided, an empty array must be passed in.<br>
* Note that this list should not contain any duplicate name.
* </p>
* <p>
* The <code>isExported</code> flag indicates whether this entry is contributed to dependent
* projects. If not exported, dependent projects will not see any of the classes from this
* entry. If exported, dependent projects will concatenate the accessible files patterns of this
* entry with the accessible files patterns of the projects, and they will concatenate the non
* accessible files patterns of this entry with the non accessible files patterns of the
* project.
* </p>
*
* @param path the absolute path of the prerequisite project
* @param accessRules the possibly empty list of access rules for this entry
* @param combineAccessRules whether the access rules of the project's exported entries should
* be combined with the given access rules
* @param extraAttributes the possibly empty list of extra attributes to persist with this entry
* @param isExported indicates whether this entry is contributed to dependent projects in
* addition to the output location
* @return a new project classpath entry
* @since 3.1
*/
public static IClasspathEntry newProjectEntry(
IPath path,
IAccessRule[] accessRules,
boolean combineAccessRules,
IClasspathAttribute[] extraAttributes,
boolean isExported) {
if (!path.isAbsolute())
throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
if (accessRules == null) {
accessRules= ClasspathEntry.NO_ACCESS_RULES;
}
if (extraAttributes == null) {
extraAttributes= ClasspathEntry.NO_EXTRA_ATTRIBUTES;
}
return new ClasspathEntry(
IPackageFragmentRoot.K_SOURCE,
IClasspathEntry.CPE_PROJECT,
path,
ClasspathEntry.INCLUDE_ALL, // inclusion patterns
ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
null, // source attachment
null, // source attachment root
null, // specific output folder
isExported,
accessRules,
combineAccessRules,
extraAttributes);
}
/**
* Returns a new empty region.
*
* @return a new empty region
*/
public static IRegion newRegion() {
return new Region();
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> for all files in
* the project's source folder identified by the given absolute workspace-relative path.
* <p>
* The convenience method is fully equivalent to:
*
* <pre>
* newSourceEntry(path, new IPath[] {}, new IPath[] {}, null);
* </pre>
*
* </p>
*
* @param path the absolute workspace-relative path of a source folder
* @return a new source classpath entry
* @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
*/
public static IClasspathEntry newSourceEntry(IPath path) {
return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, ClasspathEntry.EXCLUDE_NONE, null /*output location*/);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> for the project's
* source folder identified by the given absolute workspace-relative path but excluding all
* source files with paths matching any of the given patterns.
* <p>
* The convenience method is fully equivalent to:
*
* <pre>
* newSourceEntry(path, new IPath[] {}, exclusionPatterns, null);
* </pre>
*
* </p>
*
* @param path the absolute workspace-relative path of a source folder
* @param exclusionPatterns the possibly empty list of exclusion patterns represented as
* relative paths
* @return a new source classpath entry
* @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
* @since 2.1
*/
public static IClasspathEntry newSourceEntry(IPath path, IPath[] exclusionPatterns) {
return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, exclusionPatterns, null /*output location*/);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> for the project's
* source folder identified by the given absolute workspace-relative path but excluding all
* source files with paths matching any of the given patterns, and associated with a specific
* output location (that is, ".class" files are not going to the project default output
* location).
* <p>
* The convenience method is fully equivalent to:
*
* <pre>
* newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation);
* </pre>
*
* </p>
*
* @param path the absolute workspace-relative path of a source folder
* @param exclusionPatterns the possibly empty list of exclusion patterns represented as
* relative paths
* @param specificOutputLocation the specific output location for this source entry (
* <code>null</code> if using project default ouput location)
* @return a new source classpath entry
* @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
* @since 2.1
*/
public static IClasspathEntry newSourceEntry(IPath path, IPath[] exclusionPatterns, IPath specificOutputLocation) {
return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, exclusionPatterns, specificOutputLocation);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> for the project's
* source folder identified by the given absolute workspace-relative path but excluding all
* source files with paths matching any of the given patterns, and associated with a specific
* output location (that is, ".class" files are not going to the project default output
* location).
* <p>
* The convenience method is fully equivalent to:
*
* <pre>
* newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation, new IClasspathAttribute[] {});
* </pre>
*
* </p>
*
* @param path the absolute workspace-relative path of a source folder
* @param inclusionPatterns the possibly empty list of inclusion patterns represented as
* relative paths
* @param exclusionPatterns the possibly empty list of exclusion patterns represented as
* relative paths
* @param specificOutputLocation the specific output location for this source entry (
* <code>null</code> if using project default ouput location)
* @return a new source classpath entry
* @see #newSourceEntry(IPath, IPath[], IPath[], IPath, IClasspathAttribute[])
* @since 3.0
*/
public static IClasspathEntry newSourceEntry(IPath path, IPath[] inclusionPatterns, IPath[] exclusionPatterns, IPath specificOutputLocation) {
return newSourceEntry(path, inclusionPatterns, exclusionPatterns, specificOutputLocation, ClasspathEntry.NO_EXTRA_ATTRIBUTES);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> for the project's
* source folder identified by the given absolute workspace-relative path using the given
* inclusion and exclusion patterns to determine which source files are included, and the given
* output path to control the output location of generated files.
* <p>
* The source folder is referred to using an absolute path relative to the workspace root, e.g.
* <code>/Project/src</code>. A project's source folders are located with that project. That is,
* a source classpath entry specifying the path <code>/P1/src</code> is only usable for project
* <code>P1</code>.
* </p>
* <p>
* The inclusion patterns determines the initial set of source files that are to be included;
* the exclusion patterns are then used to reduce this set. When no inclusion patterns are
* specified, the initial file set includes all relevent files in the resource tree rooted at
* the source entry's path. On the other hand, specifying one or more inclusion patterns means
* that all <b>and only</b> files matching at least one of the specified patterns are to be
* included. If exclusion patterns are specified, the initial set of files is then reduced by
* eliminating files matched by at least one of the exclusion patterns. Inclusion and exclusion
* patterns look like relative file paths with wildcards and are interpreted relative to the
* source entry's path. File patterns are case-sensitive can contain '**', '*' or '?' wildcards
* (see {@link IClasspathEntry#getExclusionPatterns()} for the full description of their syntax
* and semantics). The resulting set of files are included in the corresponding package fragment
* root; all package fragments within the root will have children of type
* <code>ICompilationUnit</code>.
* </p>
* <p>
* For example, if the source folder path is <code>/Project/src</code>, there are no inclusion
* filters, and the exclusion pattern is <code>com/xyz/tests/**</code>, then source
* files like <code>/Project/src/com/xyz/Foo.java</code> and
* <code>/Project/src/com/xyz/utils/Bar.java</code> would be included, whereas
* <code>/Project/src/com/xyz/tests/T1.java</code> and
* <code>/Project/src/com/xyz/tests/quick/T2.java</code> would be excluded.
* </p>
* <p>
* Additionally, a source entry can be associated with a specific output location. By doing so,
* the Java builder will ensure that the generated ".class" files will be issued inside this
* output location, as opposed to be generated into the project default output location (when
* output location is <code>null</code>). Note that multiple source entries may target the same
* output location. The output location is referred to using an absolute path relative to the
* workspace root, e.g. <code>"/Project/bin"</code>, it must be located inside the same project
* as the source folder.
* </p>
* <p>
* Also note that all sources/binaries inside a project are contributed as a whole through a
* project entry (see <code>JavaCore.newProjectEntry</code>). Particular source entries cannot
* be selectively exported.
* </p>
* <p>
* The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
* this entry. If no extra attributes are provided, an empty array must be passed in.<br>
* Note that this list should not contain any duplicate name.
* </p>
*
* @param path the absolute workspace-relative path of a source folder
* @param inclusionPatterns the possibly empty list of inclusion patterns represented as
* relative paths
* @param exclusionPatterns the possibly empty list of exclusion patterns represented as
* relative paths
* @param specificOutputLocation the specific output location for this source entry (
* <code>null</code> if using project default ouput location)
* @param extraAttributes the possibly empty list of extra attributes to persist with this entry
* @return a new source classpath entry with the given exclusion patterns
* @see IClasspathEntry#getInclusionPatterns()
* @see IClasspathEntry#getExclusionPatterns()
* @see IClasspathEntry#getOutputLocation()
* @since 3.1
*/
public static IClasspathEntry newSourceEntry(IPath path, IPath[] inclusionPatterns, IPath[] exclusionPatterns, IPath specificOutputLocation, IClasspathAttribute[] extraAttributes) {
if (path == null)
throw new ClasspathEntry.AssertionFailedException("Source path cannot be null"); //$NON-NLS-1$
if (!path.isAbsolute())
throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
if (exclusionPatterns == null) {
exclusionPatterns= ClasspathEntry.EXCLUDE_NONE;
}
if (inclusionPatterns == null) {
inclusionPatterns= ClasspathEntry.INCLUDE_ALL;
}
if (extraAttributes == null) {
extraAttributes= ClasspathEntry.NO_EXTRA_ATTRIBUTES;
}
return new ClasspathEntry(
IPackageFragmentRoot.K_SOURCE,
IClasspathEntry.CPE_SOURCE,
path,
inclusionPatterns,
exclusionPatterns,
null, // source attachment
null, // source attachment root
specificOutputLocation, // custom output location
false,
null,
false, // no access rules to combine
extraAttributes);
}
/**
* Creates and returns a new non-exported classpath entry of kind <code>CPE_VARIABLE</code> for
* the given path. This method is fully equivalent to calling
* {@link #newVariableEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
* newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, new
* IAccessRule[0], new IClasspathAttribute[0], false)}.
*
* @param variablePath the path of the binary archive; first segment is the name of a classpath
* variable
* @param variableSourceAttachmentPath the path of the corresponding source archive, or
* <code>null</code> if none; if present, the first segment is the name of a
* classpath variable (not necessarily the same variable as the one that begins
* <code>variablePath</code>)
* @param sourceAttachmentRootPath the location of the root of the source files within the
* source archive or <code>null</code> if <code>variableSourceAttachmentPath</code>
* is also <code>null</code>
* @return a new library classpath entry
*/
public static IClasspathEntry newVariableEntry(
IPath variablePath,
IPath variableSourceAttachmentPath,
IPath sourceAttachmentRootPath) {
return newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, false);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_VARIABLE</code> for the given
* path. This method is fully equivalent to calling
* {@link #newVariableEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
* newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, new
* IAccessRule[0], new IClasspathAttribute[0], isExported)}.
*
* @param variablePath the path of the binary archive; first segment is the name of a classpath
* variable
* @param variableSourceAttachmentPath the path of the corresponding source archive, or
* <code>null</code> if none; if present, the first segment is the name of a
* classpath variable (not necessarily the same variable as the one that begins
* <code>variablePath</code>)
* @param variableSourceAttachmentRootPath the location of the root of the source files within
* the source archive or <code>null</code> if
* <code>variableSourceAttachmentPath</code> is also <code>null</code>
* @param isExported indicates whether this entry is contributed to dependent projects in
* addition to the output location
* @return a new variable classpath entry
* @since 2.0
*/
public static IClasspathEntry newVariableEntry(
IPath variablePath,
IPath variableSourceAttachmentPath,
IPath variableSourceAttachmentRootPath,
boolean isExported) {
return newVariableEntry(
variablePath,
variableSourceAttachmentPath,
variableSourceAttachmentRootPath,
ClasspathEntry.NO_ACCESS_RULES,
ClasspathEntry.NO_EXTRA_ATTRIBUTES,
isExported);
}
/**
* Creates and returns a new classpath entry of kind <code>CPE_VARIABLE</code> for the given
* path. The first segment of the path is the name of a classpath variable. The trailing
* segments of the path will be appended to resolved variable path.
* <p>
* A variable entry allows to express indirect references on a classpath to other projects or
* libraries, depending on what the classpath variable is referring.
* <p>
* It is possible to register an automatic initializer (
* <code>ClasspathVariableInitializer</code>), which will be invoked through the extension point
* "org.eclipse.jdt.core.classpathVariableInitializer". After resolution, a classpath variable
* entry may either correspond to a project or a library entry.
* <p>
* e.g. Here are some examples of variable path usage
* <ul>
* <li>"JDTCORE" where variable <code>JDTCORE</code> is bound to "c:/jars/jdtcore.jar". The
* resolved classpath entry is denoting the library "c:\jars\jdtcore.jar"</li>
* <li>"JDTCORE" where variable <code>JDTCORE</code> is bound to "/Project_JDTCORE". The
* resolved classpath entry is denoting the project "/Project_JDTCORE"</li>
* <li>"PLUGINS/com.example/example.jar" where variable <code>PLUGINS</code> is bound to
* "c:/eclipse/plugins". The resolved classpath entry is denoting the library
* "c:\eclipse\plugins\com.example\example.jar"</li>
* </ul>
* <p>
* The access rules determine the set of accessible class files in the project or library. If
* the list of access rules is empty then all files in this project or library are accessible.
* See {@link IAccessRule} for a detailed description of access rules.
* </p>
* <p>
* The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
* this entry. If no extra attributes are provided, an empty array must be passed in.<br>
* Note that this list should not contain any duplicate name.
* </p>
* <p>
* The <code>isExported</code> flag indicates whether this entry is contributed to dependent
* projects. If not exported, dependent projects will not see any of the classes from this
* entry. If exported, dependent projects will concatenate the accessible files patterns of this
* entry with the accessible files patterns of the projects, and they will concatenate the non
* accessible files patterns of this entry with the non accessible files patterns of the
* project.
* </p>
* <p>
* Note that this operation does not attempt to validate classpath variables or access the
* resources at the given paths.
* </p>
*
* @param variablePath the path of the binary archive; first segment is the name of a classpath
* variable
* @param variableSourceAttachmentPath the path of the corresponding source archive, or
* <code>null</code> if none; if present, the first segment is the name of a
* classpath variable (not necessarily the same variable as the one that begins
* <code>variablePath</code>)
* @param variableSourceAttachmentRootPath the location of the root of the source files within
* the source archive or <code>null</code> if
* <code>variableSourceAttachmentPath</code> is also <code>null</code>
* @param accessRules the possibly empty list of access rules for this entry
* @param extraAttributes the possibly empty list of extra attributes to persist with this entry
* @param isExported indicates whether this entry is contributed to dependent projects in
* addition to the output location
* @return a new variable classpath entry
* @since 3.1
*/
public static IClasspathEntry newVariableEntry(
IPath variablePath,
IPath variableSourceAttachmentPath,
IPath variableSourceAttachmentRootPath,
IAccessRule[] accessRules,
IClasspathAttribute[] extraAttributes,
boolean isExported) {
if (variablePath == null)
throw new ClasspathEntry.AssertionFailedException("Variable path cannot be null"); //$NON-NLS-1$
if (variablePath.segmentCount() < 1) {
throw new ClasspathEntry.AssertionFailedException("Illegal classpath variable path: \'" + variablePath.makeRelative().toString() + "\', must have at least one segment"); //$NON-NLS-1$//$NON-NLS-2$
}
if (accessRules == null) {
accessRules= ClasspathEntry.NO_ACCESS_RULES;
}
if (extraAttributes == null) {
extraAttributes= ClasspathEntry.NO_EXTRA_ATTRIBUTES;
}
return new ClasspathEntry(
IPackageFragmentRoot.K_SOURCE,
IClasspathEntry.CPE_VARIABLE,
variablePath,
ClasspathEntry.INCLUDE_ALL, // inclusion patterns
ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
variableSourceAttachmentPath, // source attachment
variableSourceAttachmentRootPath, // source attachment root
null, // specific output folder
isExported,
accessRules,
false, // no access rules to combine
extraAttributes);
}
/**
* Returns an array of classpath entries that are referenced directly or indirectly by a given
* classpath entry. For the entry kind {@link IClasspathEntry#CPE_LIBRARY}, the method returns
* the libraries that are included in the Class-Path section of the MANIFEST.MF file. If a
* referenced JAR file has further references to other library entries, they are processed
* recursively and added to the list. For entry kinds other than
* {@link IClasspathEntry#CPE_LIBRARY}, this method returns an empty array.
* <p>
* When a non-null project is passed, any additional attributes that may have been stored
* previously in the project's .classpath file are retrieved and populated in the corresponding
* referenced entry. If the project is <code>null</code>, the raw referenced entries are
* returned without any persisted attributes. For more details on storing referenced entries,
* see
* {@link IJavaProject#setRawClasspath(IClasspathEntry[], IClasspathEntry[], IPath, IProgressMonitor)}
* .
* </p>
*
* @param libraryEntry the library entry whose referenced entries are sought
* @param project project where the persisted referenced entries to be retrieved from. If
* <code>null</code> persisted attributes are not attempted to be retrived.
* @return an array of classpath entries that are referenced directly or indirectly by the given
* entry. If not applicable, returns an empty array.
* @since 3.6
*/
public static IClasspathEntry[] getReferencedClasspathEntries(IClasspathEntry libraryEntry, IJavaProject project) {
JavaModelManager manager= JavaModelManager.getJavaModelManager();
return manager.getReferencedClasspathEntries(libraryEntry, project);
}
/**
* Removed the given classpath variable. Does nothing if no value was set for this classpath
* variable.
* <p>
* This functionality cannot be used while the resource tree is locked.
* <p>
* Classpath variable values are persisted locally to the workspace, and are preserved from
* session to session.
* <p>
*
* @param variableName the name of the classpath variable
* @see #setClasspathVariable(String, IPath)
*
* @deprecated Use {@link #removeClasspathVariable(String, IProgressMonitor)} instead
*/
public static void removeClasspathVariable(String variableName) {
removeClasspathVariable(variableName, null);
}
/**
* Removed the given classpath variable. Does nothing if no value was set for this classpath
* variable.
* <p>
* This functionality cannot be used while the resource tree is locked.
* <p>
* Classpath variable values are persisted locally to the workspace, and are preserved from
* session to session.
* <p>
*
* @param variableName the name of the classpath variable
* @param monitor the progress monitor to report progress
* @see #setClasspathVariable(String, IPath)
*/
public static void removeClasspathVariable(String variableName, IProgressMonitor monitor) {
try {
SetVariablesOperation operation= new SetVariablesOperation(new String[] { variableName }, new IPath[] { null }, true/*update preferences*/);
operation.runOperation(monitor);
} catch (JavaModelException e) {
Util.log(e, "Exception while removing variable " + variableName); //$NON-NLS-1$
}
}
/**
* Removes the given element changed listener. Has no affect if an identical listener is not
* registered.
*
* @param listener the listener
*/
public static void removeElementChangedListener(IElementChangedListener listener) {
JavaModelManager.getDeltaState().removeElementChangedListener(listener);
}
/**
* Removes the file extension from the given file name, if it has a Java-like file extension.
* Otherwise the file name itself is returned. Note this removes the dot ('.') before the
* extension as well.
*
* @param fileName the name of a file
* @return the fileName without the Java-like extension
* @since 3.2
*/
public static String removeJavaLikeExtension(String fileName) {
return Util.getNameWithoutJavaLikeExtension(fileName);
}
/**
* Removes the given pre-processing resource changed listener.
* <p>
* Has no affect if an identical listener is not registered.
*
* @param listener the listener
* @since 3.0
*/
public static void removePreProcessingResourceChangedListener(IResourceChangeListener listener) {
JavaModelManager.getDeltaState().removePreResourceChangedListener(listener);
}
/**
* Runs the given action as an atomic Java model operation.
* <p>
* After running a method that modifies java elements, registered listeners receive
* after-the-fact notification of what just transpired, in the form of a element changed event.
* This method allows clients to call a number of methods that modify java elements and only
* have element changed event notifications reported at the end of the entire batch.
* </p>
* <p>
* If this method is called outside the dynamic scope of another such call, this method runs the
* action and then reports a single element changed event describing the net effect of all
* changes done to java elements by the action.
* </p>
* <p>
* If this method is called in the dynamic scope of another such call, this method simply runs
* the action.
* </p>
*
* @param action the action to perform
* @param monitor a progress monitor, or <code>null</code> if progress reporting and
* cancellation are not desired
* @exception CoreException if the operation failed.
* @since 2.1
*/
public static void run(IWorkspaceRunnable action, IProgressMonitor monitor) throws CoreException {
run(action, ResourcesPlugin.getWorkspace().getRoot(), monitor);
}
/**
* Runs the given action as an atomic Java model operation.
* <p>
* After running a method that modifies java elements, registered listeners receive
* after-the-fact notification of what just transpired, in the form of a element changed event.
* This method allows clients to call a number of methods that modify java elements and only
* have element changed event notifications reported at the end of the entire batch.
* </p>
* <p>
* If this method is called outside the dynamic scope of another such call, this method runs the
* action and then reports a single element changed event describing the net effect of all
* changes done to java elements by the action.
* </p>
* <p>
* If this method is called in the dynamic scope of another such call, this method simply runs
* the action.
* </p>
* <p>
* The supplied scheduling rule is used to determine whether this operation can be run
* simultaneously with workspace changes in other threads. See <code>IWorkspace.run(...)</code>
* for more details.
* </p>
*
* @param action the action to perform
* @param rule the scheduling rule to use when running this operation, or <code>null</code> if
* there are no scheduling restrictions for this operation.
* @param monitor a progress monitor, or <code>null</code> if progress reporting and
* cancellation are not desired
* @exception CoreException if the operation failed.
* @since 3.0
*/
public static void run(IWorkspaceRunnable action, ISchedulingRule rule, IProgressMonitor monitor) throws CoreException {
IWorkspace workspace= ResourcesPlugin.getWorkspace();
if (workspace.isTreeLocked()) {
new BatchOperation(action).run(monitor);
} else {
// use IWorkspace.run(...) to ensure that a build will be done in autobuild mode
workspace.run(new BatchOperation(action), rule, IWorkspace.AVOID_UPDATE, monitor);
}
}
/**
* Bind a container reference path to some actual containers (<code>IClasspathContainer</code>).
* This API must be invoked whenever changes in container need to be reflected onto the
* JavaModel. Containers can have distinct values in different projects, therefore this API
* considers a set of projects with their respective containers.
* <p>
* <code>containerPath</code> is the path under which these values can be referenced through
* container classpath entries (<code>IClasspathEntry#CPE_CONTAINER</code>). A container path is
* formed by a first ID segment followed with extra segments, which can be used as additional
* hints for the resolution. The container ID is used to identify a
* <code>ClasspathContainerInitializer</code> registered on the extension point
* "org.eclipse.jdt.core.classpathContainerInitializer".
* <p>
* There is no assumption that each individual container value passed in argument (
* <code>respectiveContainers</code>) must answer the exact same path when requested
* <code>IClasspathContainer#getPath</code>. Indeed, the containerPath is just an indication for
* resolving it to an actual container object. It can be delegated to a
* <code>ClasspathContainerInitializer</code>, which can be activated through the extension
* point "org.eclipse.jdt.core.ClasspathContainerInitializer").
* <p>
* In reaction to changing container values, the JavaModel will be updated to reflect the new
* state of the updated container. A combined Java element delta will be notified to describe
* the corresponding classpath changes resulting from the container update. This operation is
* batched, and automatically eliminates unnecessary updates (new container is same as old one).
* This operation acquires a lock on the workspace's root.
* <p>
* This functionality cannot be used while the workspace is locked, since it may create/remove
* some resource markers.
* <p>
* Classpath container values are persisted locally to the workspace, but are not preserved from
* a session to another. It is thus highly recommended to register a
* <code>ClasspathContainerInitializer</code> for each referenced container (through the
* extension point "org.eclipse.jdt.core.ClasspathContainerInitializer").
* <p>
* Note: setting a container to <code>null</code> will cause it to be lazily resolved again
* whenever its value is required. In particular, this will cause a registered initializer to be
* invoked again.
* <p>
*
* @param containerPath - the name of the container reference, which is being updated
* @param affectedProjects - the set of projects for which this container is being bound
* @param respectiveContainers - the set of respective containers for the affected projects
* @param monitor a monitor to report progress
* @throws JavaModelException
* @see ClasspathContainerInitializer
* @see #getClasspathContainer(IPath, IJavaProject)
* @see IClasspathContainer
* @since 2.0
*/
public static void setClasspathContainer(IPath containerPath, IJavaProject[] affectedProjects, IClasspathContainer[] respectiveContainers, IProgressMonitor monitor) throws JavaModelException {
if (affectedProjects.length != respectiveContainers.length)
throw new ClasspathEntry.AssertionFailedException("Projects and containers collections should have the same size"); //$NON-NLS-1$
if (affectedProjects.length == 1) {
IClasspathContainer container= respectiveContainers[0];
if (container != null) {
JavaModelManager manager= JavaModelManager.getJavaModelManager();
IJavaProject project= affectedProjects[0];
IClasspathContainer existingCointainer= manager.containerGet(project, containerPath);
if (existingCointainer == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) {
manager.containerBeingInitializedPut(project, containerPath, container);
return;
}
}
}
SetContainerOperation operation= new SetContainerOperation(containerPath, affectedProjects, respectiveContainers);
operation.runOperation(monitor);
}
/**
* Sets the value of the given classpath variable. The path must have at least one segment.
* <p>
* This functionality cannot be used while the resource tree is locked.
* <p>
* Classpath variable values are persisted locally to the workspace, and are preserved from
* session to session.
* <p>
*
* @param variableName the name of the classpath variable
* @param path the path
* @throws JavaModelException
* @see #getClasspathVariable(String)
*
* @deprecated Use {@link #setClasspathVariable(String, IPath, IProgressMonitor)} instead
*/
public static void setClasspathVariable(String variableName, IPath path)
throws JavaModelException {
setClasspathVariable(variableName, path, null);
}
/**
* Sets the value of the given classpath variable. The path must not be null. Since 3.5, the
* path to a library can also be relative to the project using ".." as the first segment.
* <p>
* This functionality cannot be used while the resource tree is locked.
* <p>
* Classpath variable values are persisted locally to the workspace, and are preserved from
* session to session.
* <p>
* Updating a variable with the same value has no effect.
*
* @param variableName the name of the classpath variable
* @param path the path
* @param monitor a monitor to report progress
* @throws JavaModelException
* @see #getClasspathVariable(String)
*/
public static void setClasspathVariable(
String variableName,
IPath path,
IProgressMonitor monitor)
throws JavaModelException {
if (path == null)
throw new ClasspathEntry.AssertionFailedException("Variable path cannot be null"); //$NON-NLS-1$
setClasspathVariables(new String[] { variableName }, new IPath[] { path }, monitor);
}
/**
* Sets the values of all the given classpath variables at once. Null paths can be used to
* request corresponding variable removal. Since 3.5, the path to a library can also be relative
* to the project using ".." as the first segment.
* <p>
* A combined Java element delta will be notified to describe the corresponding classpath
* changes resulting from the variables update. This operation is batched, and automatically
* eliminates unnecessary updates (new variable is same as old one). This operation acquires a
* lock on the workspace's root.
* <p>
* This functionality cannot be used while the workspace is locked, since it may create/remove
* some resource markers.
* <p>
* Classpath variable values are persisted locally to the workspace, and are preserved from
* session to session.
* <p>
* Updating a variable with the same value has no effect.
*
* @param variableNames an array of names for the updated classpath variables
* @param paths an array of path updates for the modified classpath variables (null meaning that
* the corresponding value will be removed
* @param monitor a monitor to report progress
* @throws JavaModelException
* @see #getClasspathVariable(String)
* @since 2.0
*/
public static void setClasspathVariables(
String[] variableNames,
IPath[] paths,
IProgressMonitor monitor)
throws JavaModelException {
if (variableNames.length != paths.length)
throw new ClasspathEntry.AssertionFailedException("Variable names and paths collections should have the same size"); //$NON-NLS-1$
SetVariablesOperation operation= new SetVariablesOperation(variableNames, paths, true/*update preferences*/);
operation.runOperation(monitor);
}
/**
* Sets the default compiler options inside the given options map according to the given
* compliance.
*
* <p>
* The given compliance must be one of those supported by the compiler, that is one of the
* acceptable values for option {@link #COMPILER_COMPLIANCE}.
*
* <p>
* The list of modified options is currently:
* </p>
* <ul>
* <li>{@link #COMPILER_COMPLIANCE}</li>
* <li>{@link #COMPILER_SOURCE}</li>
* <li>{@link #COMPILER_CODEGEN_TARGET_PLATFORM}</li>
* <li>{@link #COMPILER_PB_ASSERT_IDENTIFIER}</li>
* <li>{@link #COMPILER_PB_ENUM_IDENTIFIER}</li>
* <li>{@link #COMPILER_CODEGEN_INLINE_JSR_BYTECODE} for compliance levels 1.5 and greater</li>
* </ul>
*
* <p>
* If the given compliance is unknown, the given map is unmodified.
* </p>
*
* @param compliance the given compliance
* @param options the given options map
* @since 3.3
*/
public static void setComplianceOptions(String compliance, Map options) {
switch ((int)(CompilerOptions.versionToJdkLevel(compliance) >>> 16)) {
case ClassFileConstants.MAJOR_VERSION_1_3:
options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_3);
options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_3);
options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_1);
options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.IGNORE);
options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.IGNORE);
break;
case ClassFileConstants.MAJOR_VERSION_1_4:
options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_4);
options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_3);
options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_2);
options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.WARNING);
options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.WARNING);
break;
case ClassFileConstants.MAJOR_VERSION_1_5:
options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);
options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_5);
options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
break;
case ClassFileConstants.MAJOR_VERSION_1_6:
options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_6);
options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_6);
options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_6);
options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
break;
case ClassFileConstants.MAJOR_VERSION_1_7:
options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_7);
options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_7);
options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_7);
options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
}
}
/**
* Sets the current table of options. All and only the options explicitly included in the given
* table are remembered; all previous option settings are forgotten, including ones not
* explicitly mentioned.
* <p>
* Helper constants have been defined on JavaCore for each of the option IDs (categorized in
* Code assist option ID, Compiler option ID and Core option ID) and some of their acceptable
* values (categorized in Option value). Some options accept open value sets beyond the
* documented constant values.
* <p>
* Note: each release may add new options.
*
* @param newOptions the new options (key type: <code>String</code>; value type:
* <code>String</code>), or <code>null</code> to reset all options to their default
* values
* @see JavaCore#getDefaultOptions()
* @see JavaCorePreferenceInitializer for changing default settings
*/
public static void setOptions(Hashtable newOptions) {
JavaModelManager.getJavaModelManager().setOptions(newOptions);
}
/* (non-Javadoc)
* Shutdown the JavaCore plug-in.
* <p>
* De-registers the JavaModelManager as a resource changed listener and save participant.
* <p>
* @see org.eclipse.core.runtime.Plugin#stop(BundleContext)
*/
public void stop(BundleContext context) throws Exception {
try {
JavaModelManager.getJavaModelManager().shutdown();
} finally {
// ensure we call super.stop as the last thing
super.stop(context);
}
}
/* (non-Javadoc)
* Startup the JavaCore plug-in.
* <p>
* Registers the JavaModelManager as a resource changed listener and save participant.
* Starts the background indexing, and restore saved classpath variable values.
* <p>
* @throws Exception
* @see org.eclipse.core.runtime.Plugin#start(BundleContext)
*/
public void start(BundleContext context) throws Exception {
super.start(context);
JavaModelManager.getJavaModelManager().startup();
}
}