Java tutorial
/******************************************************************************* * Copyright (c) 2000, 2016 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation * IBM Corporation - added the following constants: * COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE * COMPILER_PB_STATIC_ACCESS_RECEIVER * COMPILER_TASK_TAGS * CORE_CIRCULAR_CLASSPATH * CORE_INCOMPLETE_CLASSPATH * IBM Corporation - added run(IWorkspaceRunnable, IProgressMonitor) * IBM Corporation - added exclusion patterns to source classpath entries * IBM Corporation - added specific output location to source classpath entries * IBM Corporation - added the following constants: * CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER * CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER * CLEAN * IBM Corporation - added getClasspathContainerInitializer(String) * IBM Corporation - added the following constants: * CODEASSIST_ARGUMENT_PREFIXES * CODEASSIST_ARGUMENT_SUFFIXES * CODEASSIST_FIELD_PREFIXES * CODEASSIST_FIELD_SUFFIXES * CODEASSIST_LOCAL_PREFIXES * CODEASSIST_LOCAL_SUFFIXES * CODEASSIST_STATIC_FIELD_PREFIXES * CODEASSIST_STATIC_FIELD_SUFFIXES * COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION * IBM Corporation - added the following constants: * COMPILER_PB_LOCAL_VARIABLE_HIDING * COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD * COMPILER_PB_FIELD_HIDING * COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT * CORE_INCOMPATIBLE_JDK_LEVEL * VERSION_1_5 * COMPILER_PB_EMPTY_STATEMENT * IBM Corporation - added the following constants: * COMPILER_PB_INDIRECT_STATIC_ACCESS * COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION * COMPILER_PB_UNNECESSARY_CAST * IBM Corporation - added the following constants: * COMPILER_PB_INVALID_JAVADOC * COMPILER_PB_INVALID_JAVADOC_TAGS * COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY * COMPILER_PB_MISSING_JAVADOC_TAGS * COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY * COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING * COMPILER_PB_MISSING_JAVADOC_COMMENTS * COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY * COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING * COMPILER_PB_DEPRECATION_WHEN_OVERRIDING_DEPRECATED_METHOD * COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING * IBM Corporation - added the following constants: * TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC * IBM Corporation - added the following constants: * COMPILER_PB_FALLTHROUGH_CASE * COMPILER_PB_PARAMETER_ASSIGNMENT * COMPILER_PB_NULL_REFERENCE * IBM Corporation - added the following constants: * CODEASSIST_DEPRECATION_CHECK * IBM Corporation - added the following constants: * COMPILER_PB_POTENTIAL_NULL_REFERENCE * COMPILER_PB_REDUNDANT_NULL_CHECK * IBM Corporation - added the following constants: * COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE * IBM Corporation - added the following constants: * COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE * IBM Corporation - added the following constants: * COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION * COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_NO_TAG * COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_RETURN_TAG * COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_TAGS * IBM Corporation - added the following constants: * COMPILER_PB_REDUNDANT_SUPERINTERFACE * IBM Corporation - added the following constant: * COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE * IBM Corporation - added getOptionForConfigurableSeverity(int) * Benjamin Muskalla - added COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD * Stephan Herrmann - added COMPILER_PB_UNUSED_OBJECT_ALLOCATION * Stephan Herrmann - added COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS * Stephan Herrmann - added the following constants: * COMPILER_PB_UNCLOSED_CLOSEABLE, * COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE * COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE * COMPILER_ANNOTATION_NULL_ANALYSIS * COMPILER_NULLABLE_ANNOTATION_NAME * COMPILER_NONNULL_ANNOTATION_NAME * COMPILER_PB_NULL_SPECIFICATION_VIOLATION * COMPILER_PB_POTENTIAL_NULL_SPECIFICATION_VIOLATION * COMPILER_PB_NULL_SPECIFICATION_INSUFFICIENT_INFO * COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT * COMPILER_PB_SWITCH_MISSING_DEFAULT_CASE * COMPILER_INHERIT_NULL_ANNOTATIONS * COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED * COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS * Jesper S Moller - Contributions for bug 381345 : [1.8] Take care of the Java 8 major version * - added the following constants: * COMPILER_CODEGEN_METHOD_PARAMETERS_ATTR * Harry Terkelsen (het@google.com) - Bug 449262 - Allow the use of third-party Java formatters * Gbor Kvesdn - Contribution for Bug 350000 - [content assist] Include non-prefix matches in auto-complete suggestions * *******************************************************************************/ 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.runtime.CoreException; import org.eclipse.core.runtime.IConfigurationElement; import org.eclipse.core.runtime.IExtension; import org.eclipse.core.runtime.IExtensionPoint; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.OperationCanceledException; import org.eclipse.core.runtime.Path; import org.eclipse.core.runtime.Platform; import org.eclipse.core.runtime.Plugin; import org.eclipse.core.runtime.QualifiedName; import org.eclipse.core.runtime.SubMonitor; import org.eclipse.core.runtime.jobs.ISchedulingRule; import org.eclipse.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.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.*; 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. */ @SuppressWarnings({ "unchecked", "rawtypes" }) public final class JavaCore extends Plugin { private static final IResource[] NO_GENERATED_RESOURCES = new IResource[0]; private static Plugin JAVA_CORE_PLUGIN = null; /** * The plug-in identifier of the Java core support * (value <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).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.debug.localVariable"</code></dd> * <dt>Possible values:</dt><dd><code>{ "generate", "do not generate" }</code></dd> * <dt>Default:</dt><dd><code>"generate"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_LOCAL_VARIABLE_ATTR = PLUGIN_ID + ".compiler.debug.localVariable"; //$NON-NLS-1$ /** * Compiler option ID: Generating Line Number Debug Attribute. * <p>When generated, this attribute will enable source code highlighting in debugger * (.class file is then bigger).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.debug.lineNumber"</code></dd> * <dt>Possible values:</dt><dd><code>{ "generate", "do not generate" }</code></dd> * <dt>Default:</dt><dd><code>"generate"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_LINE_NUMBER_ATTR = PLUGIN_ID + ".compiler.debug.lineNumber"; //$NON-NLS-1$ /** * Compiler option ID: Generating Source Debug Attribute. * <p>When generated, this attribute will enable the debugger to present the * corresponding source code.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.debug.sourceFile"</code></dd> * <dt>Possible values:</dt><dd><code>{ "generate", "do not generate" }</code></dd> * <dt>Default:</dt><dd><code>"generate"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_SOURCE_FILE_ATTR = PLUGIN_ID + ".compiler.debug.sourceFile"; //$NON-NLS-1$ /** * Compiler option ID: Preserving Unused Local Variables. * <p>Unless requested to preserve unused local variables (that is, never read), the * compiler will optimize them out, potentially altering debugging.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.unusedLocal"</code></dd> * <dt>Possible values:</dt><dd><code>{ "preserve", "optimize out" }</code></dd> * <dt>Default:</dt><dd><code>"preserve"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_CODEGEN_UNUSED_LOCAL = PLUGIN_ID + ".compiler.codegen.unusedLocal"; //$NON-NLS-1$ /** * Compiler option ID: Generating Method Parameters Attribute. * <p>When generated, this attribute will enable information about the formal parameters of a method * (such as their names) to be accessed from reflection libraries, annotation processing, * code weaving, and in the debugger, from platform target level 1.8 and later.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.methodParameters"</code></dd> * <dt>Possible values:</dt><dd><code>{ "generate", "do not generate" }</code></dd> * <dt>Default:</dt><dd><code>"do not generate"</code></dd> * </dl> * @since 3.10 * @category CompilerOptionID */ public static final String COMPILER_CODEGEN_METHOD_PARAMETERS_ATTR = PLUGIN_ID + ".compiler.codegen.methodParameters"; //$NON-NLS-1$ /** * Compiler option ID: Defining Target Java Platform. * <p>For binary compatibility reasons, .class files are tagged with a minimal required VM version.</p> * <p>Note that <code>"1.4"</code> and higher target versions require the compliance mode to be at least as high * as the target version. Usually, compliance, target, and source versions are set to the same values.</p> * <p><code>"cldc1.1"</code> requires the source version to be <code>"1.3"</code> and the compliance version to be <code>"1.4"</code> or lower.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.targetPlatform"</code></dd> * <dt>Possible values:</dt><dd><code>{ "1.1", "cldc1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8" }</code></dd> * <dt>Default:</dt><dd><code>"1.2"</code></dd> * </dl> * @category CompilerOptionID * @see #COMPILER_COMPLIANCE * @see #COMPILER_SOURCE * @see #setComplianceOptions(String, Map) */ public static final String COMPILER_CODEGEN_TARGET_PLATFORM = PLUGIN_ID + ".compiler.codegen.targetPlatform"; //$NON-NLS-1$ /** * Compiler option ID: Inline JSR Bytecode Instruction. * <p>When enabled, the compiler will no longer generate JSR instructions, but rather inline corresponding * subroutine code sequences (mostly corresponding to try finally blocks). The generated code will thus * get bigger, but will load faster on virtual machines since the verification process is then much simpler.</p> * <p>This mode is anticipating support for the Java Specification Request 202.</p> * <p>Note that JSR inlining is optional only for target platform lesser than 1.5. From 1.5 on, the JSR * inlining is mandatory (also see related setting {@link #COMPILER_CODEGEN_TARGET_PLATFORM}).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_CODEGEN_INLINE_JSR_BYTECODE = PLUGIN_ID + ".compiler.codegen.inlineJsrBytecode"; //$NON-NLS-1$ /** * Compiler option ID: Javadoc Comment Support. * <p>When this support is disabled, the compiler will ignore all javadoc problems options settings * and will not report any javadoc problem. It will also not find any reference in javadoc comment and * DOM AST Javadoc node will be only a flat text instead of having structured tag elements.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.doc.comment.support"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_DOC_COMMENT_SUPPORT = PLUGIN_ID + ".compiler.doc.comment.support"; //$NON-NLS-1$ /** * @deprecated Discontinued since turning off would violate language specs. * @category DeprecatedOptionID */ 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.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_PB_OVERRIDING_PACKAGE_DEFAULT_METHOD = PLUGIN_ID + ".compiler.problem.overridingPackageDefaultMethod"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Method With Constructor Name. * <p>Naming a method with a constructor name is generally considered poor * style programming. When enabling this option, the compiler will signal such * scenario either as an error or a warning.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME = PLUGIN_ID + ".compiler.problem.methodWithConstructorName"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Deprecation. * <p>When enabled, the compiler will signal use of deprecated API either as an * error or a warning.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_PB_DEPRECATION = PLUGIN_ID + ".compiler.problem.deprecation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Deprecation Inside Deprecated Code. * <p>When enabled, the compiler will signal use of deprecated API inside deprecated code.</p> * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 2.1 * @category CompilerOptionID */ public static final String COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE = PLUGIN_ID + ".compiler.problem.deprecationInDeprecatedCode"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Deprecation When Overriding Deprecated Method. * <p>When enabled, the compiler will signal the declaration of a method overriding a deprecated one.</p> * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_DEPRECATION}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_DEPRECATION_WHEN_OVERRIDING_DEPRECATED_METHOD = "org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Hidden Catch Block. * <p>Locally to a try statement, some catch blocks may hide others. For example,</p> * <pre> * try { throw new java.io.CharConversionException(); * } catch (java.io.CharConversionException e) { * } catch (java.io.IOException e) {}. * </pre> * <p>When enabling this option, the compiler will issue an error or a warning for hidden * catch blocks corresponding to checked exceptions.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_PB_HIDDEN_CATCH_BLOCK = PLUGIN_ID + ".compiler.problem.hiddenCatchBlock"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Local. * <p>When enabled, the compiler will issue an error or a warning for unused local * variables (that is, variables never read from).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLocal"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_LOCAL = PLUGIN_ID + ".compiler.problem.unusedLocal"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Parameter. * <p>When enabled, the compiler will issue an error or a warning for unused method * parameters (that is, parameters never read from).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameter"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_PARAMETER = PLUGIN_ID + ".compiler.problem.unusedParameter"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Exception Parameter. * <p>When enabled, the compiler will issue an error or a warning for unused exception * parameters (that is, the thrown exception is never read from).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @category CompilerOptionID * @since 3.11 */ public static final String COMPILER_PB_UNUSED_EXCEPTION_PARAMETER = PLUGIN_ID + ".compiler.problem.unusedExceptionParameter"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Parameter if Implementing Abstract Method. * <p>When enabled, the compiler will signal unused parameters in abstract method implementations.</p> * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 2.1 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_PARAMETER_WHEN_IMPLEMENTING_ABSTRACT = PLUGIN_ID + ".compiler.problem.unusedParameterWhenImplementingAbstract"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Parameter if Overriding Concrete Method. * <p>When enabled, the compiler will signal unused parameters in methods overriding concrete ones.</p> * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 2.1 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_PARAMETER_WHEN_OVERRIDING_CONCRETE = PLUGIN_ID + ".compiler.problem.unusedParameterWhenOverridingConcrete"; //$NON-NLS-1$ /** * Compiler option ID: Consider Reference in Doc Comment for Unused Parameter Check. * <p>When enabled, the compiler will consider doc comment references to parameters (i.e. <code>@param</code> clauses) for the unused * parameter check. Thus, documented parameters will be considered as mandated as per doc contract.</p> * <p>The severity of the unused parameter problem is controlled with option {@link #COMPILER_PB_UNUSED_PARAMETER}.</p> * <p>Note: this option has no effect until the doc comment support is enabled according to the * option {@link #COMPILER_DOC_COMMENT_SUPPORT}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.3 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE = PLUGIN_ID + ".compiler.problem.unusedParameterIncludeDocCommentReference"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Import. * <p>When enabled, the compiler will issue an error or a warning for unused import * reference.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedImport"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 2.0 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_IMPORT = PLUGIN_ID + ".compiler.problem.unusedImport"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Presence of Type Arguments for a Non-Generic Method Invocation. * <p>When enabled, the compiler will issue an error or a warning whenever type arguments are encountered for a * non-generic method invocation. Note that prior to compliance level is <code>"1.7"</code>, this situation would automatically result * in an error. From Java7 on, unused type arguments are being tolerated, and optionally warned against.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedTypeArgumentsForMethodInvocation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.4 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_TYPE_ARGUMENTS_FOR_METHOD_INVOCATION = PLUGIN_ID + ".compiler.problem.unusedTypeArgumentsForMethodInvocation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Synthetic Access Emulation. * <p>When enabled, the compiler will issue an error or a warning whenever it emulates * access to a non-accessible member of an enclosing type. Such access can have * performance implications.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @category CompilerOptionID */ public static final String COMPILER_PB_SYNTHETIC_ACCESS_EMULATION = PLUGIN_ID + ".compiler.problem.syntheticAccessEmulation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Type Parameter. * <p>When enabled, the compiler will issue an error or a warning whenever it encounters an * unused type parameter. </p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedTypeParameter"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.9 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_TYPE_PARAMETER = PLUGIN_ID + ".compiler.problem.unusedTypeParameter"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Non-Externalized String Literal. * <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>).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 2.0 * @category CompilerOptionID */ public static final String COMPILER_PB_NON_NLS_STRING_LITERAL = PLUGIN_ID + ".compiler.problem.nonExternalizedStringLiteral"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Usage of <code>'assert'</code> Identifier. * <p>When enabled, the compiler will issue an error or a warning whenever <code>'assert'</code> is * used as an identifier (reserved keyword in 1.4).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.assertIdentifier"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 2.0 * @category CompilerOptionID */ public static final String COMPILER_PB_ASSERT_IDENTIFIER = PLUGIN_ID + ".compiler.problem.assertIdentifier"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Usage of <code>'enum'</code> Identifier. * <p>When enabled, the compiler will issue an error or a warning whenever <code>'enum'</code> is * used as an identifier (reserved keyword in 1.5).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.enumIdentifier"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_ENUM_IDENTIFIER = PLUGIN_ID + ".compiler.problem.enumIdentifier"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Non-Static Reference to a Static Member. * <p>When enabled, the compiler will issue an error or a warning whenever a static field * or method is accessed with an expression receiver. A reference to a static member should * be qualified with a type name.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 2.1 * @category CompilerOptionID */ public static final String COMPILER_PB_STATIC_ACCESS_RECEIVER = PLUGIN_ID + ".compiler.problem.staticAccessReceiver"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Indirect Reference to a Static Member. * <p>When enabled, the compiler will issue an error or a warning whenever a static field * or method is accessed in an indirect way. A reference to a static member should * preferably be qualified with its declaring type name.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_INDIRECT_STATIC_ACCESS = PLUGIN_ID + ".compiler.problem.indirectStaticAccess"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Assignment with no Effect. * <p>When enabled, the compiler will issue an error or a warning whenever an assignment * has no effect (e.g <code>'x = x'</code>).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.noEffectAssignment"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 2.1 * @category CompilerOptionID */ public static final String COMPILER_PB_NO_EFFECT_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.noEffectAssignment"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Interface Method not Compatible with non-Inherited Methods. * <p>When enabled, the compiler will issue an error or a warning whenever an interface * defines a method incompatible with a non-inherited <code>Object</code> method. Until this conflict * is resolved, such an interface cannot be implemented. For example,</p> * <pre> * interface I { * int clone(); * } * </pre> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 2.1 * @category CompilerOptionID */ public static final String COMPILER_PB_INCOMPATIBLE_NON_INHERITED_INTERFACE_METHOD = PLUGIN_ID + ".compiler.problem.incompatibleNonInheritedInterfaceMethod"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Private Members. * <p>When enabled, the compiler will issue an error or a warning whenever a private * method or field is declared but never used within the same unit.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 2.1 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_PRIVATE_MEMBER = PLUGIN_ID + ".compiler.problem.unusedPrivateMember"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Local Variable Declaration Hiding another Variable. * <p>When enabled, the compiler will issue an error or a warning whenever a local variable * declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.localVariableHiding"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_LOCAL_VARIABLE_HIDING = PLUGIN_ID + ".compiler.problem.localVariableHiding"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Special Parameter Hiding another Field. * <p>When enabled, the compiler will signal cases where a constructor or setter method parameter declaration * is hiding some field (either locally, inherited or defined in enclosing type).</p> * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_LOCAL_VARIABLE_HIDING}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD = PLUGIN_ID + ".compiler.problem.specialParameterHidingField"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Field Declaration Hiding another Variable. * <p>When enabled, the compiler will issue an error or a warning whenever a field * declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fieldHiding"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_FIELD_HIDING = PLUGIN_ID + ".compiler.problem.fieldHiding"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Type Declaration Hiding another Type. * <p>When enabled, the compiler will issue an error or a warning in situations where a type parameter * declaration is hiding some type, when a nested type is hiding some type parameter, or when * a nested type is hiding another nested type defined in same unit.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.typeParameterHiding"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_TYPE_PARAMETER_HIDING = PLUGIN_ID + ".compiler.problem.typeParameterHiding"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Possible Accidental Boolean Assignment. * <p>When enabled, the compiler will issue an error or a warning if a boolean assignment is acting as the condition * of a control statement (where it probably was meant to be a boolean comparison).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.possibleAccidentalBooleanAssignment"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Switch Fall-Through Case. * <p>When enabled, the compiler will issue an error or a warning if a case may be * entered by falling through previous case. Empty cases are allowed.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.fallthroughCase"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.2 * @category CompilerOptionID */ public static final String COMPILER_PB_FALLTHROUGH_CASE = PLUGIN_ID + ".compiler.problem.fallthroughCase"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Empty Statements and Unnecessary Semicolons. * <p>When enabled, the compiler will issue an error or a warning if an empty statement or a * unnecessary semicolon is encountered.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.emptyStatement"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_EMPTY_STATEMENT = PLUGIN_ID + ".compiler.problem.emptyStatement"; //$NON-NLS-1$ /** * Compiler option ID. * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.booleanMethodThrowingException"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID * @deprecated - this option has no effect */ public static final String COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION = PLUGIN_ID + ".compiler.problem.booleanMethodThrowingException"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unnecessary Type Check. * <p>When enabled, the compiler will issue an error or a warning when a cast or an <code>instanceof</code> operation * is unnecessary.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_UNNECESSARY_TYPE_CHECK = PLUGIN_ID + ".compiler.problem.unnecessaryTypeCheck"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unnecessary Else. * <p>When enabled, the compiler will issue an error or a warning when a statement is unnecessarily * nested within an <code>else</code> clause (in situation where then clause is not completing normally).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unnecessaryElse"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_UNNECESSARY_ELSE = PLUGIN_ID + ".compiler.problem.unnecessaryElse"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Undocumented Empty Block. * <p>When enabled, the compiler will issue an error or a warning when an empty block is detected and it is not * documented with any comment.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_UNDOCUMENTED_EMPTY_BLOCK = PLUGIN_ID + ".compiler.problem.undocumentedEmptyBlock"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Finally Blocks Not Completing Normally. * <p>When enabled, the compiler will issue an error or a warning when a finally block does not complete normally.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_FINALLY_BLOCK_NOT_COMPLETING = PLUGIN_ID + ".compiler.problem.finallyBlockNotCompletingNormally"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Declared Thrown Exception. * <p>When enabled, the compiler will issue an error or a warning when a * method or a constructor is declaring a checked exception as thrown, * but its body actually raises neither that exception, nor any other * exception extending it.</p> * <p>This diagnostic is further tuned by options * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE}, * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE}, * and {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownException"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Declared Thrown Exception in Overriding Method. * <p>When disabled, the compiler will report unused declared thrown * exceptions neither on overriding methods nor on implementing methods.</p> * <p>The severity of the unused declared thrown exception problem is * controlled with option {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.</p> * <p>This diagnostic is further tuned by options * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE} and * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"; //$NON-NLS-1$ /** * Compiler option ID: Consider Reference in Doc Comment for Unused Declared Thrown Exception Check. * <p>When enabled, the compiler will consider doc comment references to * exceptions (i.e. <code>@throws</code> clauses) for the unused * declared thrown exception check. Thus, documented exceptions will be * considered as mandated as per doc contract.</p> * <p>The severity of the unused declared thrown exception problem is controlled with option {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.</p> * <p>Note: this option has no effect until the doc comment support is enabled according to the * option {@link #COMPILER_DOC_COMMENT_SUPPORT}.</p> * <p>This diagnostic is further tuned by options * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE} * and {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.4 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unused Declared Thrown Exception Exempts Exception And Throwable. * <p>When enabled, the compiler will issue an error or a warning when a * method or a constructor is declaring a checked exception else than * {@link java.lang.Throwable} or {@link java.lang.Exception} as thrown, * but its body actually raises neither that exception, nor any other * exception extending it. When disabled, the compiler will issue an * error or a warning when a method or a constructor is declaring a * checked exception (including {@link java.lang.Throwable} and * {@link java.lang.Exception}) as thrown, but its body actually raises * neither that exception, nor any other exception extending it.</p> * <p>The severity of the unused declared thrown exception problem is * controlled with option * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION}.</p> * <p>This diagnostic is further tuned by options * {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_INCLUDE_DOC_COMMENT_REFERENCE} * and {@link #COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.4 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_EXEMPT_EXCEPTION_AND_THROWABLE = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unqualified Access to Field. * <p>When enabled, the compiler will issue an error or a warning when a field is access without any qualification. * In order to improve code readability, it should be qualified, e.g. <code>'x'</code> should rather be written <code>'this.x'</code>.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_UNQUALIFIED_FIELD_ACCESS = PLUGIN_ID + ".compiler.problem.unqualifiedFieldAccess"; //$NON-NLS-1$ /** * @deprecated Use {@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>).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_UNCHECKED_TYPE_OPERATION = PLUGIN_ID + ".compiler.problem.uncheckedTypeOperation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Raw Type Reference. * <p>When enabled, the compiler will issue an error or a warning when detecting references to raw types. Raw types are * discouraged, and are intended to help interfacing with legacy code. In the future, the language specification may * reject raw references to generic types.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.rawTypeReference"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.2 * @category CompilerOptionID */ public static final String COMPILER_PB_RAW_TYPE_REFERENCE = PLUGIN_ID + ".compiler.problem.rawTypeReference"; //$NON-NLS-1$ /** * Compiler option ID: Reporting of Unavoidable Generic Type Problems due to raw APIs. * <p> When enabled, the compiler will issue an error or warning even when it detects a generics-related type problem * that could not have been avoided by the programmer, because a referenced API already contains raw types. * As an example, a type may be forced to use raw types * in its method signatures and return types because the methods it overrides from a super type are declared to * use raw types in the first place.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.7 * @category CompilerOptionID */ public static final String COMPILER_PB_UNAVOIDABLE_GENERIC_TYPE_PROBLEMS = PLUGIN_ID + ".compiler.problem.unavoidableGenericTypeProblems"; //$NON-NLS-1$ /** * Compiler option ID: Reporting final Bound for Type Parameter. * <p>When enabled, the compiler will issue an error or a warning whenever a generic type parameter is associated with a * bound corresponding to a final type; since final types cannot be further extended, the parameter is pretty useless.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.finalParameterBound"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_FINAL_PARAMETER_BOUND = PLUGIN_ID + ".compiler.problem.finalParameterBound"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Declaration of serialVersionUID Field on Serializable Class. * <p>When enabled, the compiler will issue an error or a warning whenever a serializable class is missing a local declaration * of a <code>serialVersionUID</code> field. This field must be declared as static final and be of type <code>long</code>.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingSerialVersion"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_SERIAL_VERSION = PLUGIN_ID + ".compiler.problem.missingSerialVersion"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Varargs Argument Needing a Cast in Method/Constructor Invocation. * <p>When enabled, the compiler will issue an error or a warning whenever a varargs arguments should be cast * when passed to a method/constructor invocation. (e.g. <code>Class.getMethod(String name, Class ... args )</code> * invoked with arguments <code>("foo", null)</code>).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_VARARGS_ARGUMENT_NEED_CAST = PLUGIN_ID + ".compiler.problem.varargsArgumentNeedCast"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Boxing/Unboxing Conversion. * <p>When enabled, the compiler will issue an error or a warning whenever a boxing or an unboxing * conversion is performed.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.autoboxing"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_AUTOBOXING = PLUGIN_ID + ".compiler.problem.autoboxing"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Use of Annotation Type as Super Interface. * <p>When enabled, the compiler will issue an error or a warning whenever an annotation type is used * as a super-interface. Though legal, this is discouraged.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_ANNOTATION_SUPER_INTERFACE = PLUGIN_ID + ".compiler.problem.annotationSuperInterface"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing <code>@Override</code> Annotation. * <p>When enabled, the compiler will issue an error or a warning whenever encountering a method * declaration which overrides a superclass method but has no <code>@Override</code> annotation.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_OVERRIDE_ANNOTATION = PLUGIN_ID + ".compiler.problem.missingOverrideAnnotation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing <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.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_DEPRECATED_ANNOTATION = PLUGIN_ID + ".compiler.problem.missingDeprecatedAnnotation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing HashCode Method. * <p>When enabled, the compiler will issue an error or a warning if a type * overrides Object.equals(Object) but does not override hashCode().</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.5 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_HASHCODE_METHOD = PLUGIN_ID + ".compiler.problem.missingHashCodeMethod"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Dead Code. * <p>When enabled, the compiler will issue an error or a warning if some non fatal dead code is detected. For instance, <code>if (false) foo();</code> * is not reported as truly unreachable code by the Java Language Specification. If this diagnostic is enabled, then the invocation of <code>foo()</code> is * going to be signaled as being dead code.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deadCode"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.5 * @category CompilerOptionID */ public static final String COMPILER_PB_DEAD_CODE = PLUGIN_ID + ".compiler.problem.deadCode"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Dead Code Inside Trivial If Statement. * <p>When enabled, the compiler will signal presence of dead code inside trivial IF statement, e.g. <code>if (DEBUG)...</code>.</p> * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_DEAD_CODE}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.deadCodeInTrivialIfStatement"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.5 * @category CompilerOptionID */ public static final String COMPILER_PB_DEAD_CODE_IN_TRIVIAL_IF_STATEMENT = PLUGIN_ID + ".compiler.problem.deadCodeInTrivialIfStatement"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Incomplete Enum Switch. * <p>When enabled, the compiler will issue an error or a warning * regarding each enum constant for which a corresponding case label is lacking. * Reporting is further controlled by the option {@link #COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_INCOMPLETE_ENUM_SWITCH = PLUGIN_ID + ".compiler.problem.incompleteEnumSwitch"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Enum Case In Switch Despite An Existing Default Case. * <p>This option further controls the option {@link #COMPILER_PB_INCOMPLETE_ENUM_SWITCH}:</p> * <ul> * <li>If enabled the compiler will report problems about missing enum constants even if a default case exists * in the same switch statement.</li> * <li>If disabled existence of a default case is considered as sufficient to make a switch statement complete.</li> * </ul> * This option has no effect if {@link #COMPILER_PB_INCOMPLETE_ENUM_SWITCH} is set to <code>"ignore"</code>. * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT = PLUGIN_ID + ".compiler.problem.missingEnumCaseDespiteDefault"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Default Case In Switch. * <p>When enabled, the compiler will issue an error or a warning * against each switch statement that lacks a default case.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingDefaultCase"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_SWITCH_MISSING_DEFAULT_CASE = PLUGIN_ID + ".compiler.problem.missingDefaultCase"; //$NON-NLS-1$ /** * @since 3.1 * @deprecated Use {@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:</p> * <code>LABEL: { break; }</code> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedLabel"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.2 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_LABEL = PLUGIN_ID + ".compiler.problem.unusedLabel"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Invalid Javadoc Comment. * <p>This is the generic control for the severity of Javadoc problems. * When enabled, the compiler will issue an error or a warning for a problem in Javadoc.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadoc"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_INVALID_JAVADOC = PLUGIN_ID + ".compiler.problem.invalidJavadoc"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Invalid Javadoc Tags. * <p>When enabled, the compiler will signal unbound or unexpected reference tags in Javadoc. * A <code>@throws</code> tag referencing an undeclared exception would be considered as unexpected.</p> * <p>Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc; * also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTags"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_INVALID_JAVADOC_TAGS = PLUGIN_ID + ".compiler.problem.invalidJavadocTags"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Invalid Javadoc Tags with Deprecated References. * <p>Specify whether the compiler will report deprecated references used in Javadoc tags.</p> * <p>Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc; * also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_INVALID_JAVADOC_TAGS__DEPRECATED_REF = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsDeprecatedRef"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Invalid Javadoc Tags with Not Visible References. * <p>Specify whether the compiler will report non-visible references used in Javadoc tags.</p> * <p>Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc; * also see the setting {@link #COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_INVALID_JAVADOC_TAGS__NOT_VISIBLE_REF = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsNotVisibleRef"; //$NON-NLS-1$ /** * Compiler option ID: Visibility Level For Invalid Javadoc Tags. * <p>Set the minimum visibility level for Javadoc tag problems. Below this level problems will be ignored.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility"</code></dd> * <dt>Possible values:</dt><dd><code>{ "public", "protected", "default", "private" }</code></dd> * <dt>Default:</dt><dd><code>"public"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsVisibility"; //$NON-NLS-1$ /** * Compiler option ID: Reporting missing tag description. * <p>When enabled, the compiler will report a warning or an error for any Javadoc tag missing a required description.</p> * <p>The severity of the problem is controlled with option {@link #COMPILER_PB_INVALID_JAVADOC}.</p> * <p>It does not depend on option {@link #COMPILER_PB_INVALID_JAVADOC_TAGS}.</p> * <p>When this option is valued to {@link #COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION_ALL_STANDARD_TAGS}, * a subset of the standard <a href="http://download.oracle.com/javase/6/docs/technotes/tools/windows/javadoc.html#javadoctags">Javadoc tags</a> * that have a description, text or label are checked. While this set may grow in the future, note that user-defined tags are not and will not be checked.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription"</code></dd> * <dt>Possible values:</dt><dd><code>{ "return_tag", "all_standard_tags", "no_tag" }</code></dd> * <dt>Default:</dt><dd><code>"return_tag"</code></dd> * </dl> * @since 3.4 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_JAVADOC_TAG_DESCRIPTION = PLUGIN_ID + ".compiler.problem.missingJavadocTagDescription"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Javadoc Tags. * <p>This is the generic control for the severity of Javadoc missing tag problems. * When enabled, the compiler will issue an error or a warning when tags are missing in Javadoc comments.</p> * <p>Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc; * also see the setting {@link #COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTags"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_JAVADOC_TAGS = PLUGIN_ID + ".compiler.problem.missingJavadocTags"; //$NON-NLS-1$ /** * Compiler option ID: Visibility Level For Missing Javadoc Tags. * <p>Set the minimum visibility level for Javadoc missing tag problems. Below this level problems will be ignored.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility"</code></dd> * <dt>Possible values:</dt><dd><code>{ "public", "protected", "default", "private" }</code></dd> * <dt>Default:</dt><dd><code>"public"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY = PLUGIN_ID + ".compiler.problem.missingJavadocTagsVisibility"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Javadoc Tags on Overriding Methods. * <p>Specify whether the compiler will verify overriding methods in order to report Javadoc missing tag problems.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING = PLUGIN_ID + ".compiler.problem.missingJavadocTagsOverriding"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Javadoc Tags for Method Type Parameters. * <p>Specify whether a missing <code>@param</code> for a type parameter in a method declaration should be reported. * When enabled, the compiler will issue a missing Javadoc tag error or warning for a type parameter without a * corresponding <code>@param</code> tag.</p> * <p>This option only has an effect if the compiler compliance is 1.5 or greater.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.7 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_JAVADOC_TAGS_METHOD_TYPE_PARAMETERS = PLUGIN_ID + ".compiler.problem.missingJavadocTagsMethodTypeParameters"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Javadoc Comments. * <p>This is the generic control for the severity of missing Javadoc comment problems. * When enabled, the compiler will issue an error or a warning when Javadoc comments are missing.</p> * <p>Note that this diagnosis can be enabled based on the visibility of the construct associated with the expected Javadoc; * also see the setting {@link #COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY}.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocComments"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS = PLUGIN_ID + ".compiler.problem.missingJavadocComments"; //$NON-NLS-1$ /** * Compiler option ID: Visibility Level For Missing Javadoc Comments. * <p>Set the minimum visibility level for missing Javadoc problems. Below this level problems will be ignored.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility"</code></dd> * <dt>Possible values:</dt><dd><code>{ "public", "protected", "default", "private" }</code></dd> * <dt>Default:</dt><dd><code>"public"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY = PLUGIN_ID + ".compiler.problem.missingJavadocCommentsVisibility"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Javadoc Comments on Overriding Methods. * <p>Specify whether the compiler will verify overriding methods in order to report missing Javadoc comment problems.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING = PLUGIN_ID + ".compiler.problem.missingJavadocCommentsOverriding"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Usage of <code>char[]</code> Expressions in String Concatenations. * <p>When enabled, the compiler will issue an error or a warning whenever a <code>char[]</code> expression * is used in String concatenations (for example, <code>"hello" + new char[]{'w','o','r','l','d'}</code>).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 2.1 * @category CompilerOptionID */ public static final String COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION = PLUGIN_ID + ".compiler.problem.noImplicitStringConversion"; //$NON-NLS-1$ /** * Compiler option ID: Maximum Number of Problems Reported per Compilation Unit. * <p>Specify the maximum number of problems reported on each compilation unit.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.maxProblemPerUnit"</code></dd> * <dt>Possible values:</dt><dd><code>"<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.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.parameterAssignment"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.2 * @category CompilerOptionID */ public static final String COMPILER_PB_PARAMETER_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.parameterAssignment"; //$NON-NLS-1$ /** * Compiler option ID: Reporting a method that qualifies as static, but not declared static. * <p>When enabled, the compiler will issue an error or a warning if a method has * not been declared as <code>static</code>, even though it qualifies as one.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.7 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBeStatic"; //$NON-NLS-1$ /** * Compiler option ID: Reporting a method that may qualify as static, but not declared static. * <p>When enabled, the compiler will issue an error or a warning if a method has * not been declared as <code>static</code>, even though it may qualify as one, * when another method doesn't override it.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.7 * @category CompilerOptionID */ public static final String COMPILER_PB_POTENTIALLY_MISSING_STATIC_ON_METHOD = PLUGIN_ID + ".compiler.problem.reportMethodCanBePotentiallyStatic"; //$NON-NLS-1$ /** * Compiler option ID: Reporting a resource that is not closed properly. * <p>When enabled, the compiler will issue an error or a warning if * a local variable holds a value of type <code>java.lang.AutoCloseable</code> (compliance>=1.7) * or a value of type <code>java.io.Closeable</code> (compliance<=1.6) and if * flow analysis shows that the method <code>close()</code> is not invoked locally on that value.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unclosedCloseable"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.unclosedCloseable"; //$NON-NLS-1$ /** * Compiler option ID: Reporting a resource that may not be closed properly. * <p>When enabled, the compiler will issue an error or a warning if * a local variable holds a value of type <code>java.lang.AutoCloseable</code> (compliance>=1.7) * or a value of type <code>java.io.Closeable</code> (compliance<=1.6) and if * flow analysis shows that the method <code>close()</code> is * not invoked locally on that value for all execution paths.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$ /** * Compiler option ID: Reporting a resource that is not managed by try-with-resources. * <p>When enabled, the compiler will issue an error or a warning if a local variable * holds a value of type <code>java.lang.AutoCloseable</code>, and if the method * <code>close()</code> is explicitly invoked on that resource, but the resource is * not managed by a try-with-resources block.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE = PLUGIN_ID + ".compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$ /** * Compiler option ID: Annotation-based Null Analysis. * <p>This option controls whether the compiler will use null annotations for * improved analysis of (potential) null references.</p> * <p>When enabled, the compiler will interpret the annotation types defined using * {@link #COMPILER_NONNULL_ANNOTATION_NAME} and {@link #COMPILER_NULLABLE_ANNOTATION_NAME} * as specifying whether or not a given type includes the value <code>null</code>.</p> * <p>The effect of these analyses is further controlled by the options * {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION}, * {@link #COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT} and * {@link #COMPILER_PB_NULL_UNCHECKED_CONVERSION}. * </p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nullanalysis"</code></dd> * <dt>Possible values:</dt><dd><code>{ "disabled", "enabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_ANNOTATION_NULL_ANALYSIS = PLUGIN_ID + ".compiler.annotation.nullanalysis"; //$NON-NLS-1$ /** * Compiler option ID: Name of Annotation Type for Nullable Types. * <p>This option defines a fully qualified Java type name that the compiler may use * to perform special null analysis.</p> * <p>If the annotation specified by this option is applied to a type in a method * signature or variable declaration, this will be interpreted as a specification * that <code>null</code> is a legal value in that position. Currently supported * positions are: method parameters, method return type, fields and local variables.</p> * <p>If a value whose type * is annotated with this annotation is dereferenced without checking for null, * the compiler will trigger a diagnostic as further controlled by * {@link #COMPILER_PB_POTENTIAL_NULL_REFERENCE}.</p> * <p>The compiler may furthermore check adherence to the null specification as * further controlled by {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION}, * {@link #COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT} and * {@link #COMPILER_PB_NULL_UNCHECKED_CONVERSION}.</p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nullable"</code></dd> * <dt>Possible values:</dt><dd>any legal, fully qualified Java type name; must resolve to an annotation type.</dd> * <dt>Default:</dt><dd><code>"org.eclipse.jdt.annotation.Nullable"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_NULLABLE_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nullable"; //$NON-NLS-1$ /** * Compiler option ID: Names of Secondary Annotation Types for Nullable Types. * <p>This option defines a comma-separated list of fully qualified Java type names * that the compiler may use to perform special null analysis.</p> * <p>The annotation types identified by the names in this list are interpreted in the same way * as the annotation identified by {@link #COMPILER_NULLABLE_ANNOTATION_NAME}. * The intention is to support libraries using different sets of null annotations, * in addition to those used by the current project. Secondary null annotations should not be * used in the project's own source code.</p> * <p>JDT will never actively use any secondary annotation names from this list, * i.e., inferred null annotations and content assist proposals mentioning null annotations * are always rendered using the primary name from {@link #COMPILER_NULLABLE_ANNOTATION_NAME}.</p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nullable.secondary"</code></dd> * <dt>Possible values:</dt><dd>a comma-separated list of legal, fully qualified Java type names; * each name in the list must resolve to an annotation type.</dd> * <dt>Default:</dt><dd><code>""</code></dd> * </dl> * @since 3.12 * @category CompilerOptionID */ public static final String COMPILER_NULLABLE_ANNOTATION_SECONDARY_NAMES = PLUGIN_ID + ".compiler.annotation.nullable.secondary"; //$NON-NLS-1$ /** * Compiler option ID: Name of Annotation Type for Non-Null Types. * <p>This option defines a fully qualified Java type name that the compiler may use * to perform special null analysis.</p> * <p>If the annotation specified by this option is applied to a type in a method * signature or variable declaration, this will be interpreted as a specification * that <code>null</code> is <b>not</b> a legal value in that position. Currently * supported positions are: method parameters, method return type, fields and local variables.</p> * <p>For values declared with this annotation, the compiler will never trigger a null * reference diagnostic (as controlled by {@link #COMPILER_PB_POTENTIAL_NULL_REFERENCE} * and {@link #COMPILER_PB_NULL_REFERENCE}), because the assumption is made that null * will never occur at runtime in these positions.</p> * <p>The compiler may furthermore check adherence to the null specification as further * controlled by {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION}, * {@link #COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT} and * {@link #COMPILER_PB_NULL_UNCHECKED_CONVERSION}.</p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nonnull"</code></dd> * <dt>Possible values:</dt><dd>any legal, fully qualified Java type name; must resolve to an annotation type.</dd> * <dt>Default:</dt><dd><code>"org.eclipse.jdt.annotation.NonNull"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_NONNULL_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nonnull"; //$NON-NLS-1$ /** * Compiler option ID: Names of Secondary Annotation Types for Non-Null Types. * <p>This option defines a comma-separated list of fully qualified Java type names * that the compiler may use to perform special null analysis.</p> * <p>The annotation types identified by the names in this list are interpreted in the same way * as the annotation identified by {@link #COMPILER_NONNULL_ANNOTATION_NAME}. * The intention is to support libraries using different sets of null annotations, * in addition to those used by the current project. Secondary null annotations should not be * used in the project's own source code.</p> * <p>JDT will never actively use any secondary annotation names from this list, * i.e., inferred null annotations and content assist proposals mentioning null annotations * are always rendered using the primary name from {@link #COMPILER_NONNULL_ANNOTATION_NAME}.</p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nonnull.secondary"</code></dd> * <dt>Possible values:</dt><dd>a comma-separated list of legal, fully qualified Java type names; * each name in the list must resolve to an annotation type.</dd> * <dt>Default:</dt><dd><code>""</code></dd> * </dl> * @since 3.12 * @category CompilerOptionID */ public static final String COMPILER_NONNULL_ANNOTATION_SECONDARY_NAMES = PLUGIN_ID + ".compiler.annotation.nonnull.secondary"; //$NON-NLS-1$ /** * Compiler option ID: Name of Annotation Type to specify a nullness default for unannotated types. * <p>This option defines a fully qualified Java type name that the compiler may use * to perform special null analysis.</p> * <p>If the annotation is applied without an argument, all unannotated types in method signatures * and field declarations within the annotated element will be treated as if they were specified * with the non-null annotation (see {@link #COMPILER_NONNULL_ANNOTATION_NAME}).</p> * <p>If the annotation is applied with the constant <code>false</code> as its argument * all corresponding defaults at outer scopes will be canceled for the annotated element.</p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nonnullbydefault"</code></dd> * <dt>Possible values:</dt><dd>any legal, fully qualified Java type name; must resolve to an annotation type. * That annotation type should have exactly one boolean parameter.</dd> * <dt>Default:</dt><dd><code>"org.eclipse.jdt.annotation.NonNullByDefault"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nonnullbydefault"; //$NON-NLS-1$ /** * Compiler option ID: Names of Secondary Annotation Types to specify a nullness default for unannotated types. * <p>This option defines a comma-separated list of fully qualified Java type names * that the compiler may use to perform special null analysis.</p> * <p>The annotation types identified by the names in this list are interpreted in the same way * as the annotation identified by {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}. * The intention is to support libraries using different sets of null annotations, * in addition to those used by the current project. Secondary null annotations should not be * used in the project's own source code.</p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary"</code></dd> * <dt>Possible values:</dt><dd>a comma-separated list of legal, fully qualified Java type names; * each name in the list must resolve to an annotation type.</dd> * <dt>Default:</dt><dd><code>""</code></dd> * </dl> * @since 3.12 * @category CompilerOptionID */ public static final String COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_SECONDARY_NAMES = PLUGIN_ID + ".compiler.annotation.nonnullbydefault.secondary"; //$NON-NLS-1$ /** * Compiler option ID: Reporting missing default nullness annotation. * <p>When enabled, the compiler will issue an error or a warning in the following cases:</p> * <ul> * <li> When a package does not contain a default nullness annotation, as a result of missing package-info.java * or missing default nullness annotation in package-info.java.</li> * <li> When a type inside a default package does not contain a default nullness annotation.</li> * </ul> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code>.</dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION = PLUGIN_ID + ".compiler.annotation.missingNonNullByDefaultAnnotation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Violations of Null Specifications. * <p>Depending on this option, the compiler will issue either an error or a warning * whenever one of the following situations is detected:</p> * <ol> * <li>A method declared with a nonnull annotation returns a * <em>nullable</em> expression.</li> * <li>A <em>nullable</em> expression is passed * as an argument in a method call where the corresponding parameter of the called * method is declared with a nonnull annotation.</li> * <li>A <em>nullable</em> expression is assigned * to a local variable that is declared with a nonnull annotation.</li> * <li>A method that overrides an inherited method declared with a nonnull annotation * tries to relax that contract by specifying a nullable annotation * (prohibition of contravariant return).</li> * <li>A method that overrides an inherited method which has a nullable declaration * for at least one of its parameters, tries to tighten that null contract by * specifying a nonnull annotation for its corresponding parameter * (prohibition of covariant parameters).</li> * <li>A non-static field with a nonnull annotation is not definitely assigned at * the end of each constructor.</li> * <li>A static field with a nonnull annotation is not definitely assigned in static initializers.</li> * </ol> * In the above an expression is considered as <em>nullable</em> if * either it is statically known to evaluate to the value <code>null</code>, or if it is * declared with a nullable annotation. * <p>The compiler options {@link #COMPILER_NONNULL_ANNOTATION_NAME} and * {@link #COMPILER_NULLABLE_ANNOTATION_NAME} control which annotations the compiler * shall interpret as nonnull or nullable annotations, respectively. * </p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullSpecViolation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning" }</code></dd> * <dt>Default:</dt><dd><code>"error"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_NULL_SPECIFICATION_VIOLATION = PLUGIN_ID + ".compiler.problem.nullSpecViolation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting conflicts between declared null annotation and inferred null value * <p>When enabled, the compiler will issue an error or a warning whenever one of the * following situations is detected:</p> * <ol> * <li>A method declared with a nonnull annotation returns an expression that is * statically known to evaluate to a null value on some flow.</li> * <li>An expression that is statically known to evaluate to a null value on some flow * is passed as an argument in a method call where the corresponding parameter of * the called method is declared with a nonnull annotation.</li> * <li>An expression that is statically known to evaluate to a null value on some flow * is assigned to a local variable that is declared with a nonnull annotation.</li> * </ol> * <p>The compiler options {@link #COMPILER_NONNULL_ANNOTATION_NAME} and * {@link #COMPILER_NULLABLE_ANNOTATION_NAME} control which annotations the compiler * shall interpret as nonnull or nullable annotations, respectively. * </p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"error"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_NULL_ANNOTATION_INFERENCE_CONFLICT = PLUGIN_ID + ".compiler.problem.nullAnnotationInferenceConflict"; //$NON-NLS-1$ /** * Compiler option ID: Reporting unchecked conversion from a type with unknown nullness to a null annotated type * <p>When enabled, the compiler will issue an error or a warning whenever one of the * following situations is detected:</p> * <ol> * <li>A method declared with a nonnull annotation returns an expression for which * insufficient nullness information is available for statically proving that no * flow will pass a null value at runtime.</li> * <li>An expression for which insufficient nullness information is available for * statically proving that it will never evaluate to a null value at runtime * is passed as an argument in a method call where the corresponding parameter of * the called method is declared with a nonnull annotation.</li> * <li>An expression for which insufficient nullness information is available for * statically proving that it will never evaluate to a null value at runtime * is assigned to a local variable that is declared with a nonnull annotation.</li> * </ol> * <p>Unchecked null conversion is usually a consequence of using other unannotated * variables or methods.</p> * <p>The compiler options {@link #COMPILER_NONNULL_ANNOTATION_NAME} and * {@link #COMPILER_NULLABLE_ANNOTATION_NAME} control which annotations the compiler * shall interpret as nonnull or nullable annotations, respectively. * </p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_NULL_UNCHECKED_CONVERSION = PLUGIN_ID + ".compiler.problem.nullUncheckedConversion"; //$NON-NLS-1$ /** * Compiler option ID: Reporting problems detected by pessimistic null analysis for free type variables. * <p>Unless set to <code>"ignore"</code>, type variables not affected by any explicit null annotation are pessimistically analyzed * in two directions: When reading a value of this type, it is assumed to be nullable. When this type appears as the required type * (i.e., at the left hand side of an assignment or variable initialization, or as the method return type against which a return statement * is being checked) the type is considered to require the nonnull property.</p> * <p>Problems reported due to this pessimistic analysis are reported with the level given in this option.</p> * @since 3.12 * @category CompilerOptionID * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> */ public static final String COMPILER_PB_PESSIMISTIC_NULL_ANALYSIS_FOR_FREE_TYPE_VARIABLES = PLUGIN_ID + ".compiler.problem.pessimisticNullAnalysisForFreeTypeVariables"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Redundant Null Annotations. * <p>When enabled, the compiler will issue an error or a warning when a non-null annotation * (see {@link #COMPILER_NONNULL_ANNOTATION_NAME}) * is applied although the same effect is already achieved by a default applicable at the * current location. Such a default may be set by using the annotation specified by the option * {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}. * </p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_REDUNDANT_NULL_ANNOTATION = PLUGIN_ID + ".compiler.problem.redundantNullAnnotation"; //$NON-NLS-1$ /** * Compiler option ID: Perform syntactic null analysis for fields. * <p>When enabled, the compiler will detect certain syntactic constellations where a null * related warning against a field reference would normally be raised but can be suppressed * at low risk given that the same field reference was known to be non-null immediately before.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields"</code></dd> * <dt>Possible values:</dt><dd><code>{ "disabled", "enabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.9 * @category CompilerOptionID */ public static final String COMPILER_PB_SYNTACTIC_NULL_ANALYSIS_FOR_FIELDS = JavaCore.PLUGIN_ID + ".compiler.problem.syntacticNullAnalysisForFields"; //$NON-NLS-1$ /** * Compiler option ID: Inheritance of null annotations. * <p>When enabled, the compiler will check for each method without any explicit null annotations: * If it overrides a method which has null annotations, it will treat the * current method as if it had the same annotations as the overridden method.</p> * <p>Annotation inheritance will use the <em>effective</em> nullness of the overridden method * after transitively applying inheritance and after applying any default nullness * (see {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}) at the site of the overridden method.</p> * <p>If different implicit null annotations (from a nonnull default and/or overridden methods) are applicable * to the same type in a method signature, this is flagged as an error * and an explicit null annotation must be used to disambiguate.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations"</code></dd> * <dt>Possible values:</dt><dd><code>{ "disabled", "enabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.9 * @category CompilerOptionID */ public static final String COMPILER_INHERIT_NULL_ANNOTATIONS = JavaCore.PLUGIN_ID + ".compiler.annotation.inheritNullAnnotations"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Dropped Nonnull Parameter Annotations. * <p>When enabled, the compiler will issue an error or a warning against a parameter of * a method that overrides an inherited method * if all of the following hold:</p> * <ul> * <li>The overridden method declares the corresponding parameter as non-null (see {@link #COMPILER_NONNULL_ANNOTATION_NAME}).</li> * <li>The parameter in the overriding method has no null annotation.</li> * <li>The overriding method is not affected by a nullness default (see {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}).</li> * <li>Inheritance of null annotations is disabled (see {@link #COMPILER_INHERIT_NULL_ANNOTATIONS}).</li> * </ul> * <p>This particular situation bears the same inherent risk as any unannotated method parameter, * because the compiler's null ananysis cannot decide wither <code>null</code> is or is not a legal value for this parameter. * However, the annotation in the overridden method <em>suggests</em> that the parameter should also be annotated as non-null. * If that is not intended or possible, it is recommended to annotate the parameter as nullable, * in order to make this (legal) change of contract explicit.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.9 * @category CompilerOptionID */ public static final String COMPILER_PB_NONNULL_PARAMETER_ANNOTATION_DROPPED = JavaCore.PLUGIN_ID + ".compiler.problem.nonnullParameterAnnotationDropped"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unsafe NonNull Interpretation Of Type Variables. * <p>When enabled, the compiler will issue an error or a warning against a method call * if all of the following hold:</p> * <ul> * <li>The method's declared return type is a type variable without any null annotation.</li> * <li>For the given invocation this type variable is substituted with a nonnull type.</li> * <li>The type declaring the method is provided by a third-party library.</li> * <li>No null annotations exist for this library type, neither in its class file nor using external annotations.</li> * </ul> * <p>This particular situation leverages the option to consistently substitute all occurrences of a type variable * with a nonnull type, but it bears the risk that the library type may not be aware of null annotations thus lacking * a necessary <code>@Nullable</code> annotation for a particular occurrence of a type variable.</p> * <p>This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled and when * the configured set of null annotations declares the target <code>TYPE_USE</code></p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.12 * @category CompilerOptionID */ public static final String COMPILER_PB_NONNULL_TYPEVAR_FROM_LEGACY_INVOCATION = JavaCore.PLUGIN_ID + ".compiler.problem.nonnullTypeVariableFromLegacyInvocation"; //$NON-NLS-1$ /** * Compiler option ID: Setting Source Compatibility Mode. * <p>Specify whether which source level compatibility is used. From 1.4 on, <code>'assert'</code> is a keyword * reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM * level should be set to <code>"1.4"</code> and the compliance mode should be <code>"1.4"</code>.</p> * <p>Source level 1.5 is necessary to enable generics, autoboxing, covariance, annotations, enumerations * enhanced for loop, static imports and varargs.</p> * <p>In source levels <code>"1.5"</code> and higher, the compliance and target settings should be * set to the same version as the source level.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.source"</code></dd> * <dt>Possible values:</dt><dd><code>{ "1.3", "1.4", "1.5", "1.6", "1.7", "1.8" }</code></dd> * <dt>Default:</dt><dd><code>"1.3"</code></dd> * </dl> * @since 2.0 * @category CompilerOptionID * @see #COMPILER_COMPLIANCE * @see #COMPILER_CODEGEN_TARGET_PLATFORM * @see #setComplianceOptions(String, Map) */ public static final String COMPILER_SOURCE = PLUGIN_ID + ".compiler.source"; //$NON-NLS-1$ /** * Compiler option ID: Setting Compliance Level. * <p>Select the compliance level for the compiler. * {@link #COMPILER_SOURCE} and {@link #COMPILER_CODEGEN_TARGET_PLATFORM} settings cannot be * higher than the compiler compliance level. In <code>"1.5"</code> and higher compliance, source and target settings * should match the compliance setting.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.compliance"</code></dd> * <dt>Possible values:</dt><dd><code>{ "1.3", "1.4", "1.5", "1.6", "1.7", "1.8" }</code></dd> * <dt>Default:</dt><dd><code>"1.4"</code></dd> * </dl> * @since 2.0 * @category CompilerOptionID * @see #COMPILER_SOURCE * @see #COMPILER_CODEGEN_TARGET_PLATFORM * @see #setComplianceOptions(String, Map) */ public static final String COMPILER_COMPLIANCE = PLUGIN_ID + ".compiler.compliance"; //$NON-NLS-1$ /** * Compiler option ID: 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> * <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.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.taskCaseSensitive"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.0 * @category CompilerOptionID */ public static final String COMPILER_TASK_CASE_SENSITIVE = PLUGIN_ID + ".compiler.taskCaseSensitive"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Forbidden Reference to Type with Restricted Access. * <p>When enabled, the compiler will issue an error or a warning when referring to a type that is non accessible, as defined according * to the access rule specifications.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.forbiddenReference"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"error"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_FORBIDDEN_REFERENCE = PLUGIN_ID + ".compiler.problem.forbiddenReference"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Discouraged Reference to Type with Restricted Access. * <p>When enabled, the compiler will issue an error or a warning when referring to a type with discouraged access, as defined according * to the access rule specifications.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.discouragedReference"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_DISCOURAGED_REFERENCE = PLUGIN_ID + ".compiler.problem.discouragedReference"; //$NON-NLS-1$ /** * Compiler option ID: Determining Effect of <code>@SuppressWarnings</code>. * <p>When enabled, the <code>@SuppressWarnings</code> annotation can be used to suppress some compiler warnings.</p> * <p>When disabled, all <code>@SupressWarnings</code> annotations are ignored; i.e., warnings are reported.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.suppressWarnings"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_SUPPRESS_WARNINGS = PLUGIN_ID + ".compiler.problem.suppressWarnings"; //$NON-NLS-1$ /** * Compiler option ID: Raise null related errors or warnings arising because of assert statements. * <p>When enabled, the compiler will flag all null related errors or warnings that have been enabled by the user, * irrespective of whether a variable occurred in an assert statement.</p> * <p>When disabled, the compiler will not flag null related errors or warnings on variables that got marked as maybe or definitely * <code>null</code> in an assert statement upstream.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.7 * @category CompilerOptionID */ public static final String COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS = PLUGIN_ID + ".compiler.problem.includeNullInfoFromAsserts"; //$NON-NLS-1$ /** * Compiler option ID: Further Determining the Effect of <code>@SuppressWarnings</code> if also * {@link #COMPILER_PB_SUPPRESS_WARNINGS} is enabled. * <p>When enabled, the <code>@SuppressWarnings</code> annotation can additionally be used to suppress * optional compiler diagnostics that have been configured as {@link #ERROR}.</p> * <p>When disabled, all <code>@SuppressWarnings</code> annotations only affects warnings.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.6 * @category CompilerOptionID */ public static final String COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS = PLUGIN_ID + ".compiler.problem.suppressOptionalErrors"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unhandled Warning Token for <code>@SuppressWarnings</code>. * <p>When enabled, the compiler will issue an error or a warning when encountering a token * it cannot handle inside a <code>@SuppressWarnings</code> annotation.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unhandledWarningToken"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.1 * @category CompilerOptionID */ public static final String COMPILER_PB_UNHANDLED_WARNING_TOKEN = PLUGIN_ID + ".compiler.problem.unhandledWarningToken"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Unnecessary <code>@SuppressWarnings</code>. * <p>When enabled, the compiler will issue an error or a warning when encountering <code>@SuppressWarnings</code> annotation * for which no corresponding warning got detected in the code. This diagnostic is provided to help developers to get * rid of transient <code>@SuppressWarnings</code> no longer needed. Note that <code>@SuppressWarnings("all")</code> is still * silencing the warning for unnecessary <code>@SuppressWarnings</code>, as it is the master switch to silence ALL warnings.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedWarningToken"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.4 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_WARNING_TOKEN = PLUGIN_ID + ".compiler.problem.unusedWarningToken"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Null Dereference. * <p>When enabled, the compiler will issue an error or a warning whenever a * variable that is statically known to hold a null value is used to * access a field or method.</p> * <p>Assert statements are ignored unless {@link #COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS} * is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullReference"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.2 * @category CompilerOptionID */ public static final String COMPILER_PB_NULL_REFERENCE = PLUGIN_ID + ".compiler.problem.nullReference"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Potential Null Dereference. * <p>When enabled, the compiler will issue an error or a warning whenever a * variable that has formerly been tested against null but is not (no more) * statically known to hold a non-null value is used to access a field or * method.</p> * <p>Assert statements are ignored unless {@link #COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS} * is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.potentialNullReference"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.3 * @category CompilerOptionID */ public static final String COMPILER_PB_POTENTIAL_NULL_REFERENCE = PLUGIN_ID + ".compiler.problem.potentialNullReference"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Redundant Null Check. * <p>When enabled, the compiler will issue an error or a warning whenever a * variable that is statically known to hold a null or a non-null value * is tested against null.</p> * <p>Assert statements are ignored unless {@link #COMPILER_PB_INCLUDE_ASSERTS_IN_NULL_ANALYSIS} * is enabled.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantNullCheck"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.3 * @category CompilerOptionID */ public static final String COMPILER_PB_REDUNDANT_NULL_CHECK = PLUGIN_ID + ".compiler.problem.redundantNullCheck"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Overriding method that doesn't call the super method invocation. * <p>When enabled, the compiler will issue an error or a warning if a method is overriding a method without calling * the super invocation.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.3 * @category CompilerOptionID */ public static final String COMPILER_PB_OVERRIDING_METHOD_WITHOUT_SUPER_INVOCATION = PLUGIN_ID + ".compiler.problem.overridingMethodWithoutSuperInvocation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Redundant Superinterface. * <p>When enabled, the compiler will issue an error or a warning if a type * explicitly implements an interface that is already implemented by any * of its supertypes.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantSuperinterface"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.4 * @category CompilerOptionID */ public static final String COMPILER_PB_REDUNDANT_SUPERINTERFACE = PLUGIN_ID + ".compiler.problem.redundantSuperinterface"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Comparison of Identical Expressions. * <p>When enabled, the compiler will issue an error or a warning if a comparison * is involving identical operands (e.g <code>'x == x'</code>).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.comparingIdentical"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 3.5 * @category CompilerOptionID */ public static final String COMPILER_PB_COMPARING_IDENTICAL = PLUGIN_ID + ".compiler.problem.comparingIdentical"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Missing Synchronized Modifier On Inherited Method. * <p>When enabled, the compiler will issue an error or a warning if a method * overrides a synchronized method without having a synchronized modifier.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.5 * @category CompilerOptionID */ public static final String COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD = PLUGIN_ID + ".compiler.problem.missingSynchronizedOnInheritedMethod"; //$NON-NLS-1$ /** * Compiler option ID: Reporting Allocation of an Unused Object. * <p>When enabled, the compiler will issue an error or a warning if an object is allocated but never used, * neither by holding a reference nor by invoking one of the object's methods.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.6 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_OBJECT_ALLOCATION = PLUGIN_ID + ".compiler.problem.unusedObjectAllocation"; //$NON-NLS-1$ /** * Compiler option ID: Reporting redundant specification of type arguments in class instance creation expressions. * <p>When enabled, the compiler will issue an error or a warning if type arguments are used in a class instance creation, * when the '<>' operator can be used instead.</p> * <p>This option only has an effect if the compiler compliance is 1.7 or greater.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "info", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.7.1 * @category CompilerOptionID */ public static final String COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS = PLUGIN_ID + ".compiler.problem.redundantSpecificationOfTypeArguments"; //$NON-NLS-1$ /** * Core option ID: Computing Project Build Order. * <p>Indicate whether JavaCore should enforce the project build order to be based on * the classpath prerequisite chain. When requesting to compute, this takes over * the platform default order (based on project references).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.computeJavaBuildOrder"</code></dd> * <dt>Possible values:</dt><dd><code>{ "compute", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @category CoreOptionID */ public static final String CORE_JAVA_BUILD_ORDER = PLUGIN_ID + ".computeJavaBuildOrder"; //$NON-NLS-1$ /** * Core option ID: Specifying Filters for Resource Copying Control. * <p>Allow to specify some filters to control the resource copy process.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.resourceCopyExclusionFilter"</code></dd> * <dt>Possible values:</dt><dd><code>{ "<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.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.duplicateResourceTask"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning" }</code></dd> * <dt>Default:</dt><dd><code>"warning"</code></dd> * </dl> * @since 2.1 * @category CoreOptionID */ public static final String CORE_JAVA_BUILD_DUPLICATE_RESOURCE = PLUGIN_ID + ".builder.duplicateResourceTask"; //$NON-NLS-1$ /** * Core option ID: Cleaning Output Folder(s). * <p>Indicate whether the JavaBuilder is allowed to clean the output folders * when performing full build operations.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.cleanOutputFolder"</code></dd> * <dt>Possible values:</dt><dd><code>{ "clean", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"clean"</code></dd> * </dl> * @since 2.1 * @category CoreOptionID */ public static final String CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER = PLUGIN_ID + ".builder.cleanOutputFolder"; //$NON-NLS-1$ /** * Core option ID: Recreate Modified class files in Output Folder. * <p>Indicate whether the JavaBuilder should check for any changes to .class files * in the output folders while performing incremental build operations. If changes * are detected to managed .class files, then a full build is performed, otherwise * the changes are left as is. Tools further altering generated .class files, like optimizers, * should ensure this option remains set in its default state of ignore.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.2 * @category CoreOptionID */ public static final String CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER = PLUGIN_ID + ".builder.recreateModifiedClassFileInOutputFolder"; //$NON-NLS-1$ /** * Core option ID: Reporting Incomplete Classpath. * <p>Indicate the severity of the problem reported when an entry on the classpath does not exist, * is not legitimate or is not visible (for example, a referenced project is closed).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.incompleteClasspath"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning"}</code></dd> * <dt>Default:</dt><dd><code>"error"</code></dd> * </dl> * @since 2.1 * @category CoreOptionID */ public static final String CORE_INCOMPLETE_CLASSPATH = PLUGIN_ID + ".incompleteClasspath"; //$NON-NLS-1$ /** * Core option ID: Reporting Classpath Cycle. * <p>Indicate the severity of the problem reported when a project is involved in a cycle.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.circularClasspath"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning" }</code></dd> * <dt>Default:</dt><dd><code>"error"</code></dd> * </dl> * @since 2.1 * @category CoreOptionID */ public static final String CORE_CIRCULAR_CLASSPATH = PLUGIN_ID + ".circularClasspath"; //$NON-NLS-1$ /** * Core option ID: Reporting Incompatible JDK Level for Required Binaries. * <p>Indicate the severity of the problem reported when a project prerequisites another project * or library with an incompatible target JDK level (e.g. project targeting 1.1 vm, but compiled against 1.4 libraries).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.incompatibleJDKLevel"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"ignore"</code></dd> * </dl> * @since 3.0 * @category CoreOptionID */ public static final String CORE_INCOMPATIBLE_JDK_LEVEL = PLUGIN_ID + ".incompatibleJDKLevel"; //$NON-NLS-1$ /** * Core option ID: Abort if Invalid Classpath. * <p>Allow to toggle the builder to abort if the classpath is invalid.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.builder.invalidClasspath"</code></dd> * <dt>Possible values:</dt><dd><code>{ "abort", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"abort"</code></dd> * </dl> * @since 2.0 * @category CoreOptionID */ public static final String CORE_JAVA_BUILD_INVALID_CLASSPATH = PLUGIN_ID + ".builder.invalidClasspath"; //$NON-NLS-1$ /** * Core option ID: Default Source Encoding Format. * <p>Get the default encoding format of source files. This value is * immutable and preset to the result of <code>ResourcesPlugin.getEncoding()</code>.</p> * <p>It is offered as a convenience shortcut only.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.encoding"</code></dd> * <dt>value:</dt><dd><code><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.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.classpath.exclusionPatterns"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 2.1 * @category CoreOptionID */ public static final String CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS = PLUGIN_ID + ".classpath.exclusionPatterns"; //$NON-NLS-1$ /** * Core option ID: Enabling Usage of Classpath Multiple Output Locations. * <p>When disabled, no entry on a project classpath can be associated with * a specific output location, preventing thus usage of multiple output locations.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.classpath.multipleOutputLocations"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 2.1 * @category CoreOptionID */ public static final String CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS = PLUGIN_ID + ".classpath.multipleOutputLocations"; //$NON-NLS-1$ /** * Core option ID: Reporting an output location overlapping another source location. * <p> Indicate the severity of the problem reported when a source entry's output location overlaps another * source entry.</p> * * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.classpath.outputOverlappingAnotherSource"</code></dd> * <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd> * <dt>Default:</dt><dd><code>"error"</code></dd> * </dl> * @since 3.6.4 */ public static final String CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE = PLUGIN_ID + ".classpath.outputOverlappingAnotherSource"; //$NON-NLS-1$ /** * Core option ID: Set the timeout value for retrieving the method's parameter names from javadoc. * <p>Timeout in milliseconds to retrieve the method's parameter names from javadoc.</p> * <p>If the value is <code>0</code>, the parameter names are not fetched and the raw names are returned.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc"</code></dd> * <dt>Possible values:</dt><dd><code>"<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$ /** * Core option ID: The ID of the formatter to use in formatting operations. * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.javaFormatter"</code></dd> * <dt>Default:</dt><dd><code>"org.eclipse.jdt.core.defaultJavaFormatter"</code></dd> * </dl> * @see #DEFAULT_JAVA_FORMATTER * @see #JAVA_FORMATTER_EXTENSION_POINT_ID * @since 3.11 * @category CoreOptionID */ public static final String JAVA_FORMATTER = PLUGIN_ID + ".javaFormatter"; //$NON-NLS-1$ /** * @since 2.0 * @deprecated Use {@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).</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.visibilityCheck"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 2.0 * @category CodeAssistOptionID */ public static final String CODEASSIST_VISIBILITY_CHECK = PLUGIN_ID + ".codeComplete.visibilityCheck"; //$NON-NLS-1$ /** * Code assist option ID: Activate Deprecation Sensitive Completion. * <p>When enabled, completion doesn't propose deprecated members and types.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.deprecationCheck"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.2 * @category CodeAssistOptionID */ public static final String CODEASSIST_DEPRECATION_CHECK = PLUGIN_ID + ".codeComplete.deprecationCheck"; //$NON-NLS-1$ /** * Code assist option ID: Activate Camel Case Sensitive Completion. * <p>When enabled, completion shows proposals whose name match the CamelCase * pattern.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.camelCaseMatch"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.2 * @category CodeAssistOptionID */ public static final String CODEASSIST_CAMEL_CASE_MATCH = PLUGIN_ID + ".codeComplete.camelCaseMatch"; //$NON-NLS-1$ /** * Code assist option ID: Activate Substring Code Completion. * <p>When enabled, completion shows proposals in which the pattern can * be found as a substring in a case-insensitive way.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.substringMatch"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.12 * @category CodeAssistOptionID */ public static final String CODEASSIST_SUBSTRING_MATCH = PLUGIN_ID + ".codeComplete.substringMatch"; //$NON-NLS-1$ /** * Code assist option ID: Automatic Qualification of Implicit Members. * <p>When active, completion automatically qualifies completion on implicit * field references and message expressions.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.forceImplicitQualification"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 2.0 * @category CodeAssistOptionID */ public static final String CODEASSIST_IMPLICIT_QUALIFICATION = PLUGIN_ID + ".codeComplete.forceImplicitQualification"; //$NON-NLS-1$ /** * Code assist option ID: Define the Prefixes for Field Name. * <p>When the prefixes is non empty, completion for field name will begin with * one of the proposed prefixes.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.fieldPrefixes"</code></dd> * <dt>Possible values:</dt><dd><code>{ "<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.</p> * <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.</p> * <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.</p> * <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.</p> * <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.</p> * <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.</p> * <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.</p> * <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.</p> * <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.</p> * <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.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.forbiddenReferenceCheck"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.1 * @category CodeAssistOptionID */ public static final String CODEASSIST_FORBIDDEN_REFERENCE_CHECK = PLUGIN_ID + ".codeComplete.forbiddenReferenceCheck"; //$NON-NLS-1$ /** * Code assist option ID: Activate Discouraged Reference Sensitive Completion. * <p>When enabled, completion doesn't propose elements which match a * discouraged reference rule.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.discouragedReferenceCheck"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"disabled"</code></dd> * </dl> * @since 3.1 * @category CodeAssistOptionID */ public static final String CODEASSIST_DISCOURAGED_REFERENCE_CHECK = PLUGIN_ID + ".codeComplete.discouragedReferenceCheck"; //$NON-NLS-1$ /** * Code assist option ID: Activate Suggestion of Static Import. * <p>When enabled, completion proposals can contain static import * pattern.</p> * <dl> * <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.codeComplete.suggestStaticImports"</code></dd> * <dt>Possible values:</dt><dd><code>{ "enabled", "disabled" }</code></dd> * <dt>Default:</dt><dd><code>"enabled"</code></dd> * </dl> * @since 3.3 * @category CodeAssistOptionID */ public static final String CODEASSIST_SUGGEST_STATIC_IMPORTS = PLUGIN_ID + ".codeComplete.suggestStaticImports"; //$NON-NLS-1$ // end configurable option IDs } // Begin configurable option values { /** * @deprecated Use {@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.10 * @category OptionValue */ public static final String VERSION_1_8 = "1.8"; //$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 * @since 3.12 */ public static final String INFO = "info"; //$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$ /** * The ID of the Eclipse built-in formatter. * * @see #JAVA_FORMATTER * @see #JAVA_FORMATTER_EXTENSION_POINT_ID * @since 3.11 */ public static final String DEFAULT_JAVA_FORMATTER = PLUGIN_ID + ".defaultJavaFormatter"; //$NON-NLS-1$ /** * Name of the extension point for contributing a source code formatter * @see #JAVA_FORMATTER * @see #DEFAULT_JAVA_FORMATTER * @since 3.11 */ public static final String JAVA_FORMATTER_EXTENSION_POINT_ID = "javaFormatter"; //$NON-NLS-1$ /** * Creates the Java core plug-in. * <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. * <p> * This listener will only be notified during the POST_CHANGE resource change notification * and any reconcile operation (POST_RECONCILE). * </p> * <p> * For finer control of the notification, use <code>addElementChangedListener(IElementChangedListener,int)</code>, * which allows to specify a different eventMask. * </p> * * @param listener the listener * @see ElementChangedEvent */ public static void addElementChangedListener(IElementChangedListener listener) { addElementChangedListener(listener, ElementChangedEvent.POST_CHANGE | ElementChangedEvent.POST_RECONCILE); } /** * Adds the given listener for changes to Java elements. * Has no effect if an identical listener is already registered. * After completion of this method, the given listener will be registered for exactly * the specified events. If they were previously registered for other events, they * will be deregistered. * <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: * </p> * <ul> * <li>{@link IResourceChangeEvent#PRE_BUILD}</li> * <li>{@link IResourceChangeEvent#POST_BUILD}</li> * <li>{@link IResourceChangeEvent#POST_CHANGE}</li> * <li>{@link IResourceChangeEvent#PRE_DELETE}</li> * <li>{@link IResourceChangeEvent#PRE_CLOSE}</li> * </ul> * This list may increase in the future. * * @param listener the listener * @param eventMask the bit-wise OR of all event types of interest to the * listener * @see #removePreProcessingResourceChangedListener(IResourceChangeListener) * @see IResourceChangeEvent * @since 3.2 */ public static void addPreProcessingResourceChangedListener(IResourceChangeListener listener, int eventMask) { JavaModelManager.getDeltaState().addPreResourceChangedListener(listener, eventMask); } /** * Configures the given marker for the given Java element. * Used for markers, which denote a Java element rather than a resource. * * @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:</p> * <ul> * <li>a file with one of the {@link JavaCore#getJavaLikeExtensions() * Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li> * <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li> * <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li> * </ul> * <p> * Creating a Java element has the side effect of creating and opening all of the * element's parents if they are not yet open. * </p> * * @param file the given file * @return the Java element corresponding to the given file, or * <code>null</code> if unable to associate the given file * with a Java element */ public static IJavaElement create(IFile file) { return JavaModelManager.create(file, null/*unknown java project*/); } /** * Returns the package fragment or package fragment root corresponding to the given folder, or * <code>null</code> if unable to associate the given folder with a Java element. * <p> * Note that a package fragment root is returned rather than a default package. * </p> * <p> * Creating a Java element has the side effect of creating and opening all of the * element's parents if they are not yet open. * </p> * * @param folder the given folder * @return the package fragment or package fragment root corresponding to the given folder, or * <code>null</code> if unable to associate the given folder with a Java element */ public static IJavaElement create(IFolder folder) { return JavaModelManager.create(folder, null/*unknown java project*/); } /** * Returns the Java project corresponding to the given project. * <p> * Creating a Java Project has the side effect of creating and opening all of the * project's parents if they are not yet open. * </p> * <p> * Note that no check is done at this time on the existence or the java nature of this project. * </p> * * @param project the given project * @return the Java project corresponding to the given project, null if the given project is null */ public static IJavaProject create(IProject project) { if (project == null) { return null; } JavaModel javaModel = JavaModelManager.getJavaModelManager().getJavaModel(); return javaModel.getJavaProject(project); } /** * Returns the Java element corresponding to the given resource, or * <code>null</code> if unable to associate the given resource * with a Java element. * <p> * The resource must be one of: * </p> * <ul> * <li>a project - the element returned is the corresponding <code>IJavaProject</code></li> * <li>a file with one of the {@link JavaCore#getJavaLikeExtensions() * Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li> * <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li> * <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li> * <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code> * or <code>IPackageFragment</code></li> * <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li> * </ul> * <p> * Creating a Java element has the side effect of creating and opening all of the * element's parents if they are not yet open. * </p> * * @param resource the given resource * @return the Java element corresponding to the given resource, or * <code>null</code> if unable to associate the given resource * with a Java element */ public static IJavaElement create(IResource resource) { return JavaModelManager.create(resource, null/*unknown java project*/); } /** * Returns the Java element corresponding to the given file, its project being the given * project. Returns <code>null</code> if unable to associate the given resource * with a Java element. * <p> * The resource must be one of: * </p> * <ul> * <li>a project - the element returned is the corresponding <code>IJavaProject</code></li> * <li>a file with one of the {@link JavaCore#getJavaLikeExtensions() * Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li> * <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li> * <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li> * <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code> * or <code>IPackageFragment</code></li> * <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li> * </ul> * <p> * Creating a Java element has the side effect of creating and opening all of the * element's parents if they are not yet open. * </p> * * @param resource the given resource * @return the Java element corresponding to the given file, or * <code>null</code> if unable to associate the given file * with a Java element * @since 3.3 */ public static IJavaElement create(IResource resource, IJavaProject project) { return JavaModelManager.create(resource, project); } /** * Returns the Java model. * * @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> * <p> * There is no assumption that the returned container must answer the exact same containerPath * when requested <code>IClasspathContainer#getPath</code>. * Indeed, the containerPath is just an indication for resolving it to an actual container object. * </p> * <p> * Classpath container values are persisted locally to the workspace, but * are not preserved from a session to another. It is thus highly recommended to register a * <code>ClasspathContainerInitializer</code> for each referenced container * (through the extension point "org.eclipse.jdt.core.ClasspathContainerInitializer"). * </p> * * @param containerPath the name of the container, which needs to be resolved * @param project a specific project in which the container is being resolved * @return the corresponding classpath container or <code>null</code> if unable to find one. * * @exception JavaModelException if an exception occurred while resolving the container, or if the resolved container * contains illegal entries (contains CPE_CONTAINER entries or null entries). * * @see ClasspathContainerInitializer * @see IClasspathContainer * @see #setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor) * @since 2.0 */ public static IClasspathContainer getClasspathContainer(IPath containerPath, IJavaProject project) throws JavaModelException { JavaModelManager manager = JavaModelManager.getJavaModelManager(); IClasspathContainer container = manager.getClasspathContainer(containerPath, project); if (container == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) { return manager.getPreviousSessionContainer(containerPath, project); } return container; } /** * Helper method finding the classpath container initializer registered for a given classpath container ID * or <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> * <p> * Note that classpath variables can be contributed registered initializers for, * using the extension point "org.eclipse.jdt.core.classpathVariableInitializer". * If an initializer is registered for a variable, its persisted value will be ignored: * its initializer will thus get the opportunity to rebind the variable differently on * each session. * </p> * * @param variableName the name of the classpath variable * @return the path, or <code>null</code> if none * @see #setClasspathVariable(String, IPath) */ public static IPath getClasspathVariable(final String variableName) { JavaModelManager manager = JavaModelManager.getJavaModelManager(); IPath variablePath = manager.variableGet(variableName); if (variablePath == JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS) { return manager.getPreviousSessionVariable(variableName); } if (variablePath != null) { if (variablePath == JavaModelManager.CP_ENTRY_IGNORE_PATH) return null; return variablePath; } // even if persisted value exists, initializer is given priority, only if no initializer is found the persisted value is reused final ClasspathVariableInitializer initializer = JavaCore.getClasspathVariableInitializer(variableName); if (initializer != null) { if (JavaModelManager.CP_RESOLVE_VERBOSE) verbose_triggering_variable_initialization(variableName, initializer); if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED) verbose_triggering_variable_initialization_invocation_trace(); manager.variablePut(variableName, JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS); // avoid initialization cycles boolean ok = false; try { // let OperationCanceledException go through // (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59363) initializer.initialize(variableName); variablePath = manager.variableGet(variableName); // initializer should have performed side-effect if (variablePath == JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS) return null; // break cycle (initializer did not init or reentering call) if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED) verbose_variable_value_after_initialization(variableName, variablePath); manager.variablesWithInitializer.add(variableName); ok = true; } catch (RuntimeException 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". * * @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> * <p> * Note: each release may add new options. * </p> * * @return a table of all known configurable options with their default values */ public static Hashtable<String, String> getDefaultOptions() { return JavaModelManager.getJavaModelManager().getDefaultOptions(); } /** * Returns the workspace root default charset encoding. * * @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}. * <p> * Note that a Java-like extension doesn't include the leading dot ('.'). * Also note that the "java" extension is always defined as a Java-like extension. * </p> * * @return the list of known Java-like extensions. * @since 3.2 */ public static String[] getJavaLikeExtensions() { return CharOperation.toStrings(Util.getJavaLikeExtensions()); } /** * Helper method for returning one option value only. Equivalent to <code>(String)JavaCore.getOptions().get(optionName)</code> * Note that it may answer <code>null</code> if this option does not exist. * <p> * Helper constants have been defined on JavaCore for each of the option IDs * (categorized in Code assist option ID, Compiler option ID and Core option ID) * and some of their acceptable values (categorized in Option value). Some * options accept open value sets beyond the documented constant values. * </p> * <p> * Note: each release may add new options. * </p> * * @param optionName the name of an option * @return the String value of a given option * @see JavaCore#getDefaultOptions() * @see JavaCorePreferenceInitializer for changing default settings * @since 2.0 */ public static String getOption(String optionName) { return JavaModelManager.getJavaModelManager().getOption(optionName); } /** * Returns the option that can be used to configure the severity of the * compiler problem identified by <code>problemID</code> if any, * <code>null</code> otherwise. Non-null return values are taken from the * constants defined by this class whose names start with * <code>COMPILER_PB</code> and for which the possible values of the * option are defined by <code>{ "error", "warning", "info", "ignore" }</code>. A * null return value means that the provided problem ID is unknown or that * it matches a problem whose severity cannot be configured. * @param problemID one of the problem IDs defined by {@link IProblem} * @return the option that can be used to configure the severity of the * compiler problem identified by <code>problemID</code> if any, * <code>null</code> otherwise * @since 3.4 */ public static String getOptionForConfigurableSeverity(int problemID) { return CompilerOptions.optionKeyFromIrritant(ProblemReporter.getIrritant(problemID)); } /** * Returns the table of the current options. Initially, all options have their default values, * and this method returns a table that includes all known options. * <p> * Helper constants have been defined on JavaCore for each of the option IDs * (categorized in Code assist option ID, Compiler option ID and Core option ID) * and some of their acceptable values (categorized in Option value). Some * options accept open value sets beyond the documented constant values. * </p> * <p> * Note: each release may add new options. * </p> * <p>Returns a default set of options even if the platform is not running.</p> * * @return table of current settings of all options * (key type: <code>String</code>; value type: <code>String</code>) * @see #getDefaultOptions() * @see JavaCorePreferenceInitializer for changing default settings */ public static Hashtable<String, String> getOptions() { return JavaModelManager.getJavaModelManager().getOptions(); } /** * Returns the single instance of the Java core plug-in runtime class. * * @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> * <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 across all Java projects in the workspace. Thus the * workspace root scheduling rule is used during this operation. * </p><p> * This method may return before the initialization is complete. The * initialization will then continue in a background thread. * </p><p> * This method can be called concurrently. * </p> * * @param monitor a progress monitor, or <code>null</code> if progress * reporting and cancellation are not desired * @exception CoreException if the initialization fails, * the status of the exception indicates the reason of the failure * @since 3.1 */ public static void initializeAfterLoad(IProgressMonitor monitor) throws CoreException { try { SubMonitor mainMonitor = SubMonitor.convert(monitor, Messages.javamodel_initialization, 100); mainMonitor.subTask(Messages.javamodel_configuring_classpath_containers); // initialize all containers and variables JavaModelManager manager = JavaModelManager.getJavaModelManager(); try { SubMonitor subMonitor = mainMonitor.split(50).setWorkRemaining(100); // 50% of the time is spent in initializing containers and variables subMonitor.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) { subMonitor.subTask(manager.batchContainerInitializationsProgress.subTaskName); subMonitor.worked(manager.batchContainerInitializationsProgress.getWorked()); synchronized (manager) { try { manager.wait(100); } catch (InterruptedException e) { // continue } } } } } finally { manager.batchContainerInitializationsProgress.initializeAfterLoadMonitor.set(null); } // avoid leaking source attachment properties (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=183413 ) // and recreate links for external folders if needed mainMonitor.subTask(Messages.javamodel_resetting_source_attachment_properties); final IJavaProject[] projects = manager.getJavaModel().getJavaProjects(); HashSet visitedPaths = new HashSet(); ExternalFoldersManager externalFoldersManager = JavaModelManager.getExternalManager(); for (int i = 0, length = projects.length; i < length; i++) { JavaProject javaProject = (JavaProject) projects[i]; IClasspathEntry[] classpath; try { classpath = javaProject.getResolvedClasspath(); } catch (JavaModelException e) { // project no longer exist: ignore continue; } if (classpath != null) { for (int j = 0, length2 = classpath.length; j < length2; j++) { IClasspathEntry entry = classpath[j]; if (entry.getSourceAttachmentPath() != null) { IPath entryPath = entry.getPath(); if (visitedPaths.add(entryPath)) { Util.setSourceAttachmentProperty(entryPath, null); } } // else source might have been attached by IPackageFragmentRoot#attachSource(...), we keep it if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { IPath entryPath = entry.getPath(); if (ExternalFoldersManager.isExternalFolderPath(entryPath) && externalFoldersManager.getFolder(entryPath) == null) { externalFoldersManager.addFolder(entryPath, true); } } } } } try { externalFoldersManager.createPendingFolders(mainMonitor.split(1)); } catch (JavaModelException jme) { // Creation of external folder project failed. Log it and continue; Util.log(jme, "Error while processing external folders"); //$NON-NLS-1$ } // ensure external jars are refreshed (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=93668) // before search is initialized (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=405051) final JavaModel model = manager.getJavaModel(); try { mainMonitor.subTask(Messages.javamodel_refreshing_external_jars); model.refreshExternalArchives(null/*refresh all projects*/, mainMonitor.split(1) // 1% of the time is spent in jar refresh ); } catch (JavaModelException e) { // refreshing failed: ignore } // initialize delta state mainMonitor.subTask(Messages.javamodel_initializing_delta_state); manager.deltaState.rootsAreStale = true; // in case it was already initialized before we cleaned up the source attachment properties manager.deltaState.initializeRoots(true/*initAfteLoad*/); // dummy query for waiting until the indexes are ready mainMonitor.subTask(Messages.javamodel_configuring_searchengine); 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, mainMonitor.split(47) // 47% of the time is spent in the dummy search ); } catch (JavaModelException e) { // /search failed: ignore } catch (OperationCanceledException e) { if (mainMonitor.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) mainMonitor.subTask(Messages.javamodel_getting_build_state_number); QualifiedName qName = new QualifiedName(JavaCore.PLUGIN_ID, "stateVersionNumber"); //$NON-NLS-1$ IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); String versionNumber = null; try { versionNumber = root.getPersistentProperty(qName); } catch (CoreException e) { // could not read version number: consider it is new } String newVersionNumber = Byte.toString(State.VERSION); if (!newVersionNumber.equals(versionNumber)) { // build state version number has changed: touch every projects to force a rebuild if (JavaBuilder.DEBUG) System.out.println("Build state version number has changed"); //$NON-NLS-1$ IWorkspaceRunnable runnable = new IWorkspaceRunnable() { public void run(IProgressMonitor progressMonitor2) throws CoreException { for (int i = 0, length = projects.length; i < length; i++) { IJavaProject project = projects[i]; try { if (JavaBuilder.DEBUG) System.out.println("Touching " + project.getElementName()); //$NON-NLS-1$ new ClasspathValidation((JavaProject) project).validate(); // https://bugs.eclipse.org/bugs/show_bug.cgi?id=287164 project.getProject().touch(progressMonitor2); } catch (CoreException e) { // could not touch this project: ignore } } } }; mainMonitor.subTask(Messages.javamodel_building_after_upgrade); try { ResourcesPlugin.getWorkspace().run(runnable, mainMonitor.split(1)); } catch (CoreException e) { // could not touch all projects } try { root.setPersistentProperty(qName, newVersionNumber); } catch (CoreException e) { Util.log(e, "Could not persist build state version number"); //$NON-NLS-1$ } } } 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 * * @see IClasspathEntry#getExclusionPatterns() */ 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)}. * * @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> * <p> * A container is exclusively resolved by a <code>ClasspathContainerInitializer</code> registered onto the * extension point "org.eclipse.jdt.core.classpathContainerInitializer". * </p> * <p> * A container path must be formed of at least one segment, where: * </p> * <ul> * <li> the first segment is a unique ID identifying the target container, there must be a container initializer registered * onto this ID through the extension point "org.eclipse.jdt.core.classpathContainerInitializer". </li> * <li> the remaining segments will be passed onto the initializer, and can be used as additional * hints during the initialization phase. </li> * </ul> * <p> * Example of an ClasspathContainerInitializer for a classpath container denoting a default JDK container: * </p> * <pre> * containerEntry = JavaCore.newContainerEntry(new Path("MyProvidedJDK/default")); * * <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() //$NON-NLS-1$ + "\', must have at least one segment (containerID+hints)"); //$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_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>. * <p> * This method is fully equivalent to calling * {@link #newLibraryEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean) * newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], isExported)}. * </p> * * @param path the path to the library * @param sourceAttachmentPath the absolute path of the corresponding source archive or folder, * or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote no source attachment. * and will be automatically converted to <code>null</code>. Since 3.4, this path can also denote a path external * to the workspace. * @param sourceAttachmentRootPath the location of the root of the source files within the source archive or folder * or <code>null</code> if this location should be automatically detected. * @param isExported indicates whether this entry is contributed to dependent * projects in addition to the output location * @return a new library classpath entry * @since 2.0 */ public static IClasspathEntry newLibraryEntry(IPath path, IPath sourceAttachmentPath, IPath sourceAttachmentRootPath, boolean isExported) { return newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, ClasspathEntry.NO_ACCESS_RULES, ClasspathEntry.NO_EXTRA_ATTRIBUTES, isExported); } /** * Creates and returns a new classpath entry of kind <code>CPE_LIBRARY</code> for the JAR or folder * identified by the given absolute path. This specifies that all package fragments within the root * will have children of type <code>IClassFile</code>. * <p> * A library entry is used to denote a prerequisite JAR or root folder containing binaries. * The target JAR can either be defined internally to the workspace (absolute path relative * to the workspace root), or externally to the workspace (absolute path in the file system). * The target root folder can also be defined internally to the workspace (absolute path relative * to the workspace root), or - since 3.4 - externally to the workspace (absolute path in the file system). * Since 3.5, the path to the library can also be relative to the project using ".." as the first segment. * </p> * <p> * e.g. Here are some examples of binary path usage * </p> * <ul> * <li><code> "c:\jdk1.2.2\jre\lib\rt.jar" </code> - reference to an external JAR on Windows</li> * <li><code> "/Project/someLib.jar" </code> - reference to an internal JAR on Windows or Linux</li> * <li><code> "/Project/classes/" </code> - reference to an internal binary folder on Windows or Linux</li> * <li><code> "/home/usr/classes" </code> - reference to an external binary folder on Linux</li> * <li><code> "../../lib/someLib.jar" </code> - reference to an external JAR that is a sibling of the workspace on either platform</li> * </ul> * Note that on non-Windows platform, a path <code>"/some/lib.jar"</code> is ambiguous. * It can be a path to an external JAR (its file system path being <code>"/some/lib.jar"</code>) * or it can be a path to an internal JAR (<code>"some"</code> being a project in the workspace). * Such an ambiguity is solved when the classpath entry is used (e.g. in {@link IJavaProject#getPackageFragmentRoots()}). * If the resource <code>"lib.jar"</code> exists in project <code>"some"</code>, then it is considered an * internal JAR. Otherwise it is an external JAR. * <p>Also note that this operation does not attempt to validate or access the * resources at the given paths. * </p><p> * The access rules determine the set of accessible class files * in the library. If the list of access rules is empty then all files * in this library are accessible. * See {@link IAccessRule} for a detailed description of access * rules. * </p> * <p> * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with * this entry. If no extra attributes are provided, an empty array must be passed in.<br> * Note that this list should not contain any duplicate name. * </p> * <p> * The <code>isExported</code> flag indicates whether this entry is contributed to dependent * projects. If not exported, dependent projects will not see any of the classes from this entry. * If exported, dependent projects will concatenate the accessible files patterns of this entry with the * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry * with the non accessible files patterns of the project. * </p> * <p> * Since 3.5, if the library is a ZIP archive, the "Class-Path" clause (if any) in the "META-INF/MANIFEST.MF" is read * and referenced ZIP archives are added to the {@link IJavaProject#getResolvedClasspath(boolean) resolved classpath}. * </p> * * @param path the path to the library * @param sourceAttachmentPath the absolute path of the corresponding source archive or folder, * or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote no source attachment. * and will be automatically converted to <code>null</code>. Since 3.4, this path can also denote a path external * to the workspace. * @param sourceAttachmentRootPath the location of the root of the source files within the source archive or folder * or <code>null</code> if this location should be automatically detected. * @param accessRules the possibly empty list of access rules for this entry * @param extraAttributes the possibly empty list of extra attributes to persist with this entry * @param isExported indicates whether this entry is contributed to dependent * projects in addition to the output location * @return a new library classpath entry * @since 3.1 */ public static IClasspathEntry newLibraryEntry(IPath path, IPath sourceAttachmentPath, IPath sourceAttachmentRootPath, IAccessRule[] accessRules, IClasspathAttribute[] extraAttributes, boolean isExported) { if (path == null) throw new ClasspathEntry.AssertionFailedException("Library path cannot be null"); //$NON-NLS-1$ if (accessRules == null) { accessRules = 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. * <p> * This method is fully equivalent to calling * {@link #newProjectEntry(IPath, IAccessRule[], boolean, IClasspathAttribute[], boolean) * newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], false)}. * </p> * * @param path the absolute path of the binary archive * @return a new project classpath entry */ public static IClasspathEntry newProjectEntry(IPath path) { return newProjectEntry(path, false); } /** * Creates and returns a new classpath entry of kind <code>CPE_PROJECT</code> * for the project identified by the given absolute path. * <p> * This method is fully equivalent to calling * {@link #newProjectEntry(IPath, IAccessRule[], boolean, IClasspathAttribute[], boolean) * newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], isExported)}. * </p> * * @param path the absolute path of the prerequisite project * @param isExported indicates whether this entry is contributed to dependent * projects in addition to the output location * @return a new project classpath entry * @since 2.0 */ public static IClasspathEntry newProjectEntry(IPath path, boolean isExported) { if (!path.isAbsolute()) throw new ClasspathEntry.AssertionFailedException("Path for IClasspathEntry must be absolute"); //$NON-NLS-1$ return newProjectEntry(path, ClasspathEntry.NO_ACCESS_RULES, true, ClasspathEntry.NO_EXTRA_ATTRIBUTES, isExported); } /** * Creates and returns a new classpath entry of kind <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: * </p> * <pre> * newSourceEntry(path, new IPath[] {}, new IPath[] {}, null); * </pre> * * @param path the absolute workspace-relative path of a source folder * @return a new source classpath entry * @see #newSourceEntry(IPath, IPath[], IPath[], IPath) */ public static IClasspathEntry newSourceEntry(IPath path) { return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, ClasspathEntry.EXCLUDE_NONE, null /*output location*/); } /** * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> * for the project's source folder identified by the given absolute * workspace-relative path but excluding all source files with paths * matching any of the given patterns. * <p> * The convenience method is fully equivalent to: * </p> * <pre> * newSourceEntry(path, new IPath[] {}, exclusionPatterns, null); * </pre> * * @param path the absolute workspace-relative path of a source folder * @param exclusionPatterns the possibly empty list of exclusion patterns * represented as relative paths * @return a new source classpath entry * @see #newSourceEntry(IPath, IPath[], IPath[], IPath) * @since 2.1 */ public static IClasspathEntry newSourceEntry(IPath path, IPath[] exclusionPatterns) { return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, exclusionPatterns, null /*output location*/); } /** * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> * for the project's source folder identified by the given absolute * workspace-relative path but excluding all source files with paths * matching any of the given patterns, and associated with a specific output location * (that is, ".class" files are not going to the project default output location). * <p> * The convenience method is fully equivalent to: * </p> * <pre> * newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation); * </pre> * * @param path the absolute workspace-relative path of a source folder * @param exclusionPatterns the possibly empty list of exclusion patterns * represented as relative paths * @param specificOutputLocation the specific output location for this source entry (<code>null</code> if using project default output location) * @return a new source classpath entry * @see #newSourceEntry(IPath, IPath[], IPath[], IPath) * @since 2.1 */ public static IClasspathEntry newSourceEntry(IPath path, IPath[] exclusionPatterns, IPath specificOutputLocation) { return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, exclusionPatterns, specificOutputLocation); } /** * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> * for the project's source folder identified by the given absolute * workspace-relative path but excluding all source files with paths * matching any of the given patterns, and associated with a specific output location * (that is, ".class" files are not going to the project default output location). * <p> * The convenience method is fully equivalent to: * </p> * <pre> * newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation, new IClasspathAttribute[] {}); * </pre> * * @param path the absolute workspace-relative path of a source folder * @param inclusionPatterns the possibly empty list of inclusion patterns * represented as relative paths * @param exclusionPatterns the possibly empty list of exclusion patterns * represented as relative paths * @param specificOutputLocation the specific output location for this source entry (<code>null</code> if using project default output location) * @return a new source classpath entry * @see #newSourceEntry(IPath, IPath[], IPath[], IPath, IClasspathAttribute[]) * @since 3.0 */ public static IClasspathEntry newSourceEntry(IPath path, IPath[] inclusionPatterns, IPath[] exclusionPatterns, IPath specificOutputLocation) { return newSourceEntry(path, inclusionPatterns, exclusionPatterns, specificOutputLocation, ClasspathEntry.NO_EXTRA_ATTRIBUTES); } /** * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code> * for the project's source folder identified by the given absolute * workspace-relative path using the given inclusion and exclusion patterns * to determine which source files are included, and the given output path * to control the output location of generated files. * <p> * The source folder is referred to using an absolute path relative to the * workspace root, e.g. <code>/Project/src</code>. A project's source * folders are located with that project. That is, a source classpath * entry specifying the path <code>/P1/src</code> is only usable for * project <code>P1</code>. * </p> * <p> * The inclusion patterns determines the initial set of source files that * are to be included; the exclusion patterns are then used to reduce this * set. When no inclusion patterns are specified, the initial file set * includes all relevant files in the resource tree rooted at the source * entry's path. On the other hand, specifying one or more inclusion * patterns means that all <b>and only</b> files matching at least one of * the specified patterns are to be included. If exclusion patterns are * specified, the initial set of files is then reduced by eliminating files * matched by at least one of the exclusion patterns. Inclusion and * exclusion patterns look like relative file paths with wildcards and are * interpreted relative to the source entry's path. File patterns are * case-sensitive can contain '**', '*' or '?' wildcards (see * {@link IClasspathEntry#getExclusionPatterns()} for the full description * of their syntax and semantics). The resulting set of files are included * in the corresponding package fragment root; all package fragments within * the root will have children of type <code>ICompilationUnit</code>. * </p> * <p> * For example, if the source folder path is * <code>/Project/src</code>, there are no inclusion filters, and the * exclusion pattern is * <code>com/xyz/tests/**</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> * <p> * It is possible to register an automatic initializer (<code>ClasspathVariableInitializer</code>), * which will be invoked through the extension point "org.eclipse.jdt.core.classpathVariableInitializer". * After resolution, a classpath variable entry may either correspond to a project or a library entry. * </p> * <p> * e.g. Here are some examples of variable path usage * </p> * <ul> * <li> "JDTCORE" where variable <code>JDTCORE</code> is * bound to "c:/jars/jdtcore.jar". The resolved classpath entry is denoting the library "c:\jars\jdtcore.jar"</li> * <li> "JDTCORE" where variable <code>JDTCORE</code> is * bound to "/Project_JDTCORE". The resolved classpath entry is denoting the project "/Project_JDTCORE"</li> * <li> "PLUGINS/com.example/example.jar" where variable <code>PLUGINS</code> * is bound to "c:/eclipse/plugins". The resolved classpath entry is denoting the library "c:\eclipse\plugins\com.example\example.jar"</li> * </ul> * <p> * The access rules determine the set of accessible class files * in the project or library. If the list of access rules is empty then all files * in this project or library are accessible. * See {@link IAccessRule} for a detailed description of access rules. * </p> * <p> * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with * this entry. If no extra attributes are provided, an empty array must be passed in.<br> * Note that this list should not contain any duplicate name. * </p> * <p> * The <code>isExported</code> flag indicates whether this entry is contributed to dependent * projects. If not exported, dependent projects will not see any of the classes from this entry. * If exported, dependent projects will concatenate the accessible files patterns of this entry with the * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry * with the non accessible files patterns of the project. * </p> * <p> * Note that this operation does not attempt to validate classpath variables * or access the resources at the given paths. * </p> * * @param variablePath the path of the binary archive; first segment is the * name of a classpath variable * @param variableSourceAttachmentPath the path of the corresponding source archive, * or <code>null</code> if none; if present, the first segment is the * name of a classpath variable (not necessarily the same variable * as the one that begins <code>variablePath</code>) * @param variableSourceAttachmentRootPath the location of the root of the source files within the source archive * or <code>null</code> if <code>variableSourceAttachmentPath</code> is also <code>null</code> * @param accessRules the possibly empty list of access rules for this entry * @param extraAttributes the possibly empty list of extra attributes to persist with this entry * @param isExported indicates whether this entry is contributed to dependent * projects in addition to the output location * @return a new variable classpath entry * @since 3.1 */ public static IClasspathEntry newVariableEntry(IPath variablePath, IPath variableSourceAttachmentPath, IPath variableSourceAttachmentRootPath, IAccessRule[] accessRules, IClasspathAttribute[] extraAttributes, boolean isExported) { if (variablePath == null) throw new ClasspathEntry.AssertionFailedException("Variable path cannot be null"); //$NON-NLS-1$ if (variablePath.segmentCount() < 1) { throw new ClasspathEntry.AssertionFailedException("Illegal classpath variable path: \'" //$NON-NLS-1$ + variablePath.makeRelative().toString() + "\', must have at least one segment"); //$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_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 retrieved. * @return an array of classpath entries that are referenced directly or indirectly by the given entry. * If not applicable, returns an empty array. * @since 3.6 */ public static IClasspathEntry[] getReferencedClasspathEntries(IClasspathEntry libraryEntry, IJavaProject project) { JavaModelManager manager = JavaModelManager.getJavaModelManager(); return manager.getReferencedClasspathEntries(libraryEntry, project); } /** * Removed the given classpath variable. Does nothing if no value was * set for this classpath variable. * <p> * This functionality cannot be used while the resource tree is locked. * </p> * <p> * Classpath variable values are persisted locally to the workspace, and * are preserved from session to session. * </p> * * @param variableName the name of the classpath variable * @see #setClasspathVariable(String, IPath) * * @deprecated Use {@link #removeClasspathVariable(String, IProgressMonitor)} instead */ public static void removeClasspathVariable(String variableName) { removeClasspathVariable(variableName, null); } /** * Removed the given classpath variable. Does nothing if no value was * set for this classpath variable. * <p> * This functionality cannot be used while the resource tree is locked. * </p> * <p> * Classpath variable values are persisted locally to the workspace, and * are preserved from session to session. * </p> * * @param variableName the name of the classpath variable * @param monitor the progress monitor to report progress * @see #setClasspathVariable(String, IPath) */ public static void removeClasspathVariable(String variableName, IProgressMonitor monitor) { try { SetVariablesOperation operation = new SetVariablesOperation(new String[] { variableName }, new IPath[] { null }, true/*update preferences*/); operation.runOperation(monitor); } catch (JavaModelException e) { Util.log(e, "Exception while removing variable " + variableName); //$NON-NLS-1$ } } /** * Removes the given element changed listener. * Has no effect if an identical listener is not registered. * * @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 effect if an identical listener is not registered. * </p> * * @param listener the listener * @since 3.0 */ public static void removePreProcessingResourceChangedListener(IResourceChangeListener listener) { JavaModelManager.getDeltaState().removePreResourceChangedListener(listener); } /** * 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> * <p> * There is no assumption that each individual container value passed in argument * (<code>respectiveContainers</code>) must answer the exact same path when requested * <code>IClasspathContainer#getPath</code>. * Indeed, the containerPath is just an indication for resolving it to an actual container object. It can be * delegated to a <code>ClasspathContainerInitializer</code>, which can be activated through the extension * point "org.eclipse.jdt.core.ClasspathContainerInitializer"). * </p> * <p> * In reaction to changing container values, the JavaModel will be updated to reflect the new * state of the updated container. A combined Java element delta will be notified to describe the corresponding * classpath changes resulting from the container update. This operation is batched, and automatically eliminates * unnecessary updates (new container is same as old one). This operation acquires a lock on the workspace's root. * </p> * <p> * This functionality cannot be used while the workspace is locked, since * it may create/remove some resource markers. * </p> * <p> * Classpath container values are persisted locally to the workspace, but * are not preserved from a session to another. It is thus highly recommended to register a * <code>ClasspathContainerInitializer</code> for each referenced container * (through the extension point "org.eclipse.jdt.core.ClasspathContainerInitializer"). * </p> * <p> * Note: setting a container to <code>null</code> will cause it to be lazily resolved again whenever * its value is required. In particular, this will cause a registered initializer to be invoked * again. * </p> * @param containerPath - the name of the container reference, which is being updated * @param affectedProjects - the set of projects for which this container is being bound * @param respectiveContainers - the set of respective containers for the affected projects * @param monitor a monitor to report progress * @throws JavaModelException * @see ClasspathContainerInitializer * @see #getClasspathContainer(IPath, IJavaProject) * @see IClasspathContainer * @since 2.0 */ public static void setClasspathContainer(IPath containerPath, IJavaProject[] affectedProjects, IClasspathContainer[] respectiveContainers, IProgressMonitor monitor) throws JavaModelException { if (affectedProjects.length != respectiveContainers.length) throw new ClasspathEntry.AssertionFailedException( "Projects and containers collections should have the same size"); //$NON-NLS-1$ if (affectedProjects.length == 1) { IClasspathContainer container = respectiveContainers[0]; if (container != null) { JavaModelManager manager = JavaModelManager.getJavaModelManager(); IJavaProject project = affectedProjects[0]; IClasspathContainer existingCointainer = manager.containerGet(project, containerPath); if (existingCointainer == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) { manager.containerBeingInitializedPut(project, containerPath, container); return; } } } SetContainerOperation operation = new SetContainerOperation(containerPath, affectedProjects, respectiveContainers); operation.runOperation(monitor); } /** * Sets the value of the given classpath variable. * The path must have at least one segment. * <p> * This functionality cannot be used while the resource tree is locked. * </p> * <p> * Classpath variable values are persisted locally to the workspace, and * are preserved from session to session. * </p> * * @param variableName the name of the classpath variable * @param path the path * @throws JavaModelException * @see #getClasspathVariable(String) * * @deprecated Use {@link #setClasspathVariable(String, IPath, IProgressMonitor)} instead */ public static void setClasspathVariable(String variableName, IPath path) throws JavaModelException { setClasspathVariable(variableName, path, null); } /** * Sets the value of the given classpath variable. * The path must not be null. * Since 3.5, the path to a library can also be relative to the project using ".." as the first segment. * <p> * This functionality cannot be used while the resource tree is locked. * </p> * <p> * Classpath variable values are persisted locally to the workspace, and * are preserved from session to session. * </p> * <p> * Updating a variable with the same value has no effect. * </p> * * @param variableName the name of the classpath variable * @param path the path * @param monitor a monitor to report progress * @throws JavaModelException * @see #getClasspathVariable(String) */ public static void setClasspathVariable(String variableName, IPath path, IProgressMonitor monitor) throws JavaModelException { if (path == null) throw new ClasspathEntry.AssertionFailedException("Variable path cannot be null"); //$NON-NLS-1$ setClasspathVariables(new String[] { variableName }, new IPath[] { path }, monitor); } /** * Sets the values of all the given classpath variables at once. * Null paths can be used to request corresponding variable removal. * Since 3.5, the path to a library can also be relative to the project using ".." as the first segment. * <p> * A combined Java element delta will be notified to describe the corresponding * classpath changes resulting from the variables update. This operation is batched, * and automatically eliminates unnecessary updates (new variable is same as old one). * This operation acquires a lock on the workspace's root. * </p> * <p> * This functionality cannot be used while the workspace is locked, since * it may create/remove some resource markers. * </p> * <p> * Classpath variable values are persisted locally to the workspace, and * are preserved from session to session. * </p> * <p> * Updating a variable with the same value has no effect. * </p> * * @param variableNames an array of names for the updated classpath variables * @param paths an array of path updates for the modified classpath variables (null * meaning that the corresponding value will be removed * @param monitor a monitor to report progress * @throws JavaModelException * @see #getClasspathVariable(String) * @since 2.0 */ public static void setClasspathVariables(String[] variableNames, IPath[] paths, IProgressMonitor monitor) throws JavaModelException { if (variableNames.length != paths.length) throw new ClasspathEntry.AssertionFailedException( "Variable names and paths collections should have the same size"); //$NON-NLS-1$ SetVariablesOperation operation = new SetVariablesOperation(variableNames, paths, true/*update preferences*/); operation.runOperation(monitor); } /** * Sets the default compiler options inside the given options map according * to the given compliance. * * <p>The given compliance must be one of those supported by the compiler, * that is one of the acceptable values for option {@link #COMPILER_COMPLIANCE}.</p> * * <p>The list of modified options is currently:</p> * <ul> * <li>{@link #COMPILER_COMPLIANCE}</li> * <li>{@link #COMPILER_SOURCE}</li> * <li>{@link #COMPILER_CODEGEN_TARGET_PLATFORM}</li> * <li>{@link #COMPILER_PB_ASSERT_IDENTIFIER}</li> * <li>{@link #COMPILER_PB_ENUM_IDENTIFIER}</li> * <li>{@link #COMPILER_CODEGEN_INLINE_JSR_BYTECODE} for compliance levels 1.5 and greater</li> * </ul> * * <p>If the given compliance is unknown, the given map is unmodified.</p> * * @param compliance the given {@link #COMPILER_COMPLIANCE compliance} * @param options the given options map * @since 3.3 */ public static void setComplianceOptions(String compliance, Map options) { 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); break; case ClassFileConstants.MAJOR_VERSION_1_8: options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_8); options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_8); options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_8); options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR); options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR); options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED); break; } } /** * Sets the current table of options. All and only the options explicitly * included in the given table are remembered; all previous option settings * are forgotten, including ones not explicitly mentioned. * <p> * Helper constants have been defined on JavaCore for each of the option IDs * (categorized in Code assist option ID, Compiler option ID and Core option ID) * and some of their acceptable values (categorized in Option value). Some * options accept open value sets beyond the documented constant values. * </p> * Note: each release may add new options. * * @param newOptions * the new options (key type: <code>String</code>; value type: * <code>String</code>), or <code>null</code> to reset all * options to their default values * @see JavaCore#getDefaultOptions() * @see JavaCorePreferenceInitializer for changing default settings */ public static void setOptions(Hashtable<String, String> newOptions) { JavaModelManager.getJavaModelManager().setOptions(newOptions); } /** * Compares two given versions of the Java platform. The versions being compared must both be * one of the supported values mentioned in * {@link #COMPILER_CODEGEN_TARGET_PLATFORM COMPILER_CODEGEN_TARGET_PLATFORM}, * both values from {@link #COMPILER_COMPLIANCE}, or both values from {@link #COMPILER_SOURCE}. * * @param first first version to be compared * @param second second version to be compared * @return the value {@code 0} if both versions are the same; * a value less than {@code 0} if <code>first</code> is smaller than <code>second</code>; and * a value greater than {@code 0} if <code>first</code> is higher than <code>second</code> * @since 3.12 */ public static int compareJavaVersions(String first, String second) { return Long.compare(CompilerOptions.versionToJdkLevel(first), CompilerOptions.versionToJdkLevel(second)); } /* (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.unregisterDebugOptionsListener(); JavaModelManager.getJavaModelManager().shutdown(); } finally { // ensure we call super.stop as the last thing super.stop(context); } } /* (non-Javadoc) * Startup the JavaCore plug-in. * <p> * Registers the JavaModelManager as a resource changed listener and save participant. * Starts the background indexing, and restore saved classpath variable values. * </p> * @throws Exception * @see org.eclipse.core.runtime.Plugin#start(BundleContext) */ public void start(BundleContext context) throws Exception { super.start(context); JavaModelManager.registerDebugOptionsListener(context); JavaModelManager.getJavaModelManager().startup(); } }