| jdt core - build notes 3.8 stream |
| Java development tools core |
|
Here are the build notes for the Eclipse JDT/Core plug-in project
org.eclipse.jdt.core,
describing bug resolution and substantial changes in the HEAD branch.
For more information on 3.8 planning, please refer to JDT/Core release plan,
the next milestone plan,
the overall official plan,
or the build schedule.
This present document covers all changes since Release 3.7 (also see a summary of API changes).
Maintenance of previous releases of JDT/Core is performed in parallel branches: R3.7.x, R3.6.x, R3.5.x, R3.4.x, R3.3.x, R3.2.x, R3.1.x, R3.0.x, R2.1.x, R2.0.x, R1.0.x. |
/**
* Compiler option ID: Reporting Incomplete Enum Switch.
* When enabled, the compiler will issue an error or a warning
* regarding each enum constant for which a corresponding case label is lacking.
* Reporting is further controlled by the option {@link #COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT}.
*
* Option id:"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"
* Possible values:{ "error", "warning", "ignore" }
* Default:"warning"
*
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INCOMPLETE_ENUM_SWITCH = PLUGIN_ID + ".compiler.problem.incompleteEnumSwitch"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing Enum Case In Switch Despite An Existing Default Case.
* This option further controls the option {@link #COMPILER_PB_INCOMPLETE_ENUM_SWITCH}:
*
* - If enabled the compiler will report problems about missing enum constants even if a default case exists
* in the same switch statement.
* - If disabled existence of a default case is considered as sufficient to make a switch statement complete.
*
* This option has no effect if {@link #COMPILER_PB_INCOMPLETE_ENUM_SWITCH} is set to "ignore".
*
* Option id:"org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault"
* Possible values:{ "enabled", "disabled" }
* Default:"disabled"
*
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_ENUM_CASE_DESPITE_DEFAULT = PLUGIN_ID + ".compiler.problem.missingEnumCaseDespiteDefault"; //$NON-NLS-1$
/**
* Compiler option ID: Reporting Missing Default Case In Switch.
* When enabled, the compiler will issue an error or a warning
* against each switch statement that lacks a default case.
*
* Option id:"org.eclipse.jdt.core.compiler.problem.missingDefaultCase"
* Possible values:{ "error", "warning", "ignore" }
* Default:"ignore"
*
* @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.8 */ int MissingEnumDefaultCase = Internal + 766; /** @since 3.8 */ int MissingDefaultCase = Internal + 767; /** @since 3.8 */ int MissingEnumConstantCaseDespiteDefault = FieldRelated + 768; /** @since 3.8 */ int UninitializedLocalVariableHintMissingDefault = Internal + 769; /** @since 3.8 */ int UninitializedBlankFinalFieldHintMissingDefault = FieldRelated + 770; /** @since 3.8 */ int ShouldReturnValueHintMissingDefault = MethodRelated + 771;
/** @since 3.8 */ int RedundantNullCheckOnSpecdNonNullLocalVariable = Internal + 931; /** @since 3.8 */ int SpecdNonNullLocalVariableComparisonYieldsFalse = Internal + 932; /** @since 3.8 */ int RequiredNonNullButProvidedSpecdNullable = Internal + 933;
/** @since 3.8 */ int MissingNonNullByDefaultAnnotationOnPackage = Internal + 913; /** @since 3.8 */ int MissingNonNullByDefaultAnnotationOnType = Internal + 930;
/**
* Compiler option ID: Reporting missing default nullness annotation.
*
* When enabled, the compiler will issue an error or a warning in the following cases:
*
* 1. 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.
* 2. When a type inside a default package does not contain a default nullness annotation.
*
* This option only has an effect if the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id:"org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation"
* Possible values:{ "error", "warning", "ignore" }
* Default:"ignore"
*
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_PB_MISSING_NONNULL_BY_DEFAULT_ANNOTATION = PLUGIN_ID + ".compiler.annotation.missingNonNullByDefaultAnnotation"
/** @since 3.8 */ int MissingEnumDefaultCase = Internal + 766;
/**
* Compiler option ID: Reporting Incomplete Enum Switch.
*
* When enabled, the compiler will issue an error or a warning whenever
* an enum switch statement lacks a default case.
* If no default case is given, additionally one error or warning is issued
* regarding each enum constant for which a corresponding case label is lacking.
*
* Option id: "org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"
* Possible values: { "error", "warning", "ignore" }
* Default: "warning"
* @since 3.1
* @category CompilerOptionID
*/
public static final String COMPILER_PB_INCOMPLETE_ENUM_SWITCH = PLUGIN_ID + ".compiler.problem.incompleteEnumSwitch"; //$NON-NLS-1$
/**
* Constant for the name of the encoding to be used for source attachments.
*
* <p>The value of this attribute has to be a string representation of a valid encoding. The encoding
* for a source attachment is determined in the following order: </p>
*
* <ul>
* <li> Encoding explicitly set on the source file (java or zip), i.e. org.eclipse.core.resources.IFile#getCharset(false) </li>
* <li> Encoding set on the corresponding classpath entry </li>
* <li> If the source attachment is a member of the project, then the project's default charSet</li>
* <li> Workspace default charSet </li>
* </ul>
*
* @since 3.8
*/
String SOURCE_ATTACHMENT_ENCODING = "source_encoding";
/** @since 3.8 */ int RedundantNullDefaultAnnotation = Internal + 925; /** @since 3.8 */ int RedundantNullDefaultAnnotationPackage = Internal + 926; /** @since 3.8 */ int RedundantNullDefaultAnnotationType = Internal + 927; /** @since 3.8 */ int RedundantNullDefaultAnnotationMethod = Internal + 928; /** @since 3.8 */ int ContradictoryNullAnnotations = Internal + 929;
/**
* Constant for the name of the index location attribute.
*
* The value for this attribute has to be the string representation of a URL.
* It should point to an existing index file in a folder or a jar. The URL can also be of platform protocol.
*
* @since 3.8
*/
String INDEX_LOCATION_ATTRIBUTE_NAME = "index_location";
/**
* Generates the index file for the specified jar.
*
* @param pathToJar The full path to the jar that needs to be indexed
* @param pathToIndexFile The full path to the index file that needs to be generated
* @throws IOException if the jar is not found or could not write into the index file
* @since 3.8
*/
public static void generateIndexForJar(String pathToJar, String pathToIndexFile) throws IOException;
/**
* Compiler option ID: Annotation-based Null Analysis.
*
* This option controls whether the compiler will use null annotations for
* improved analysis of (potential) null references.
*
* When enabled, the compiler will interpret the annotation types defined using
* {@link #COMPILER_NONNULL_ANNOTATION_NAME} and {@link #COMPILER_NULLABLE_ANNOTATION_NAME}
* as specifying whether or not a given type includes the value null.
*
* The effect of these analyses is further controlled by the options
* {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION},
* {@link #COMPILER_PB_POTENTIAL_NULL_SPECIFICATION_VIOLATION} and
* {@link #COMPILER_PB_NULL_SPECIFICATION_INSUFFICIENT_INFO}.
*
* Option id: "org.eclipse.jdt.core.compiler.annotation.nullanalysis"
* Possible values: { "disabled", "enabled" }
* Default: "disabled"
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_ANNOTATION_NULL_ANALYSIS = PLUGIN_ID + ".compiler.annotation.nullanalysis";
/**
* Compiler option ID: Name of Annotation Type for Nullable Types.
*
* This option defines a fully qualified Java type name that the compiler may use
* to perform special null analysis.
*
* If the annotation specified by this option is applied to a type in a method
* signature or variable declaration, this will be interpreted as a specification
* that null is a legal value in that position. Currently supported
* positions are: method parameters, method return type and local variables.
*
* If a value whose type
* is annotated with this annotation is dereferenced without checking for null,
* the compiler will trigger a diagnostic as further controlled by
* {@link #COMPILER_PB_POTENTIAL_NULL_REFERENCE}.
*
* The compiler may furthermore check adherence to the null specification as
* further controlled by {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION},
* {@link #COMPILER_PB_POTENTIAL_NULL_SPECIFICATION_VIOLATION} and
* {@link #COMPILER_PB_NULL_SPECIFICATION_INSUFFICIENT_INFO}.
*
* This option only has an effect if the the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id: "org.eclipse.jdt.core.compiler.annotation.nullable"
* Possible values: any legal, fully qualified Java type name; must resolve to an annotation type.
* Default: "org.eclipse.jdt.annotation.Nullable"
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_NULLABLE_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nullable";
/**
* Compiler option ID: Name of Annotation Type for Non-Null Types.
*
* This option defines a fully qualified Java type name that the compiler may use
* to perform special null analysis.
*
* If the annotation specified by this option is applied to a type in a method
* signature or variable declaration, this will be interpreted as a specification
* that null is not a legal value in that position. Currently
* supported positions are: method parameters, method return type and local variables.
*
* 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.
*
* The compiler may furthermore check adherence to the null specification as further
* controlled by {@link #COMPILER_PB_NULL_SPECIFICATION_VIOLATION},
* {@link #COMPILER_PB_POTENTIAL_NULL_SPECIFICATION_VIOLATION} and
* {@link #COMPILER_PB_NULL_SPECIFICATION_INSUFFICIENT_INFO}.
*
* This option only has an effect if the the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id: "org.eclipse.jdt.core.compiler.annotation.nonnull"
* Possible values: any legal, fully qualified Java type name; must resolve to an annotation type.
* Default: "org.eclipse.jdt.annotation.NonNull"
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_NONNULL_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nonnull";
/**
* Compiler option ID: Name of Annotation Type to specify a nullness default for unannotated types.
*
* This option defines a fully qualified Java type name that the compiler may use
* to perform special null analysis.
*
* If the annotation is applied without an argument, all unannotated types in method signatures
* within the annotated element will be treated as if they were specified with the non-null annotation
* (see {@link #COMPILER_NONNULL_ANNOTATION_NAME}).
*
* If the annotation is applied with the constant false as its argument
* all corresponding defaults at outer scopes will be canceled for the annotated element.
* This includes defaults specified using this annotation type or a default defined using
* the compiler option {@link #COMPILER_NONNULL_IS_DEFAULT}.
*
* This option only has an effect if the the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id: "org.eclipse.jdt.core.compiler.annotation.nonnullbydefault"
* Possible values: any legal, fully qualified Java type name; must resolve to an annotation type.
* That annotation type should have exactly one boolean parameter.
* Default: "org.eclipse.jdt.annotation.NonNullByDefault"
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME = PLUGIN_ID + ".compiler.annotation.nonnullbydefault";
/**
* Compiler option ID: Globally specify non-null as the assumed default for unannotated types.
*
* When enabled this option globally achieves the same effect
* as specifying {@link #COMPILER_NONNULL_ANNOTATION_NAME} does for individual elements.
*
* This option only has an effect if the the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id: "org.eclipse.jdt.core.compiler.annotation.nonnullisdefault"
* Possible values: { "disabled", "enabled" }.
* Default: "disabled"
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_NONNULL_IS_DEFAULT = PLUGIN_ID + ".compiler.annotation.nonnullisdefault";
/**
* Compiler option ID: Reporting Violations of Null Specifications.
*
* Depending on this option, the compiler will issue either an error or a warning
* whenever one of the following situations is detected:
*
* 1. A method declared with a nonnull annotation returns an expression that is
* statically known to evaluate to a null value.
* 2. An expression that is statically known to evaluate to a null value is passed
* as an argument in a method call where the corresponding parameter of the called
* method is declared with a nonnull annotation.
* 3. An expression that is statically known to evaluate to a null value is assigned
* to a local variable that is declared with a nonnull annotation.
* 4. A method that overrides an inherited method declared with a nonnull annotation
* tries to relax that contract by specifying a nullable annotation
* (prohibition of contravariant return).
* 5. A method that overrides an inherited method which has a nullable declaration
* for at least one of its parameters, tries to tighten that null contract by
* specifying a nonnull annotation for its corresponding parameter
* (prohibition of covariant parameters).
*
* 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.
*
* This option only has an effect if the the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id: "org.eclipse.jdt.core.compiler.problem.nullSpecViolation"
* Possible values: { "error", "warning" }
* Default: "error"
*
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_PB_NULL_SPECIFICATION_VIOLATION = PLUGIN_ID + ".compiler.problem.nullSpecViolation";
/**
* Compiler option ID: Reporting Violations of Null Specifications with Potential Null Value.
*
* When enabled, the compiler will issue an error or a warning whenever one of the
* following situations is detected:
*
* 1. A method declared with a nonnull annotation returns an expression that is
* statically known to evaluate to a null value on some flow.
* 2. An expression that is statically known to evaluate to a null value on some flow
* is passed as an argument in a method call where the corresponding parameter of
* the called method is declared with a nonnull annotation.
* 3. An expression that is statically known to evaluate to a null value on some flow
* is assigned to a local variable that is declared with a nonnull annotation.
*
* The compiler options {@link #COMPILER_NONNULL_ANNOTATION_NAME} and
* {@link #COMPILER_NULLABLE_ANNOTATION_NAME} control which annotations the compiler
* shall interpret as nonnull or nullable annotations, respectively.
*
*
* This option only has an effect if the the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id: "org.eclipse.jdt.core.compiler.problem.potentialNullSpecViolation"
* Possible values: { "error", "warning", "ignore" }
* Default: "error"
*
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_PB_POTENTIAL_NULL_SPECIFICATION_VIOLATION = PLUGIN_ID + ".compiler.problem.potentialNullSpecViolation";
/**
* Compiler option ID: Reporting Insufficient Information for Analysing Adherence to Null Specifications.
*
* When enabled, the compiler will issue an error or a warning whenever one of the
* following situations is detected:
*
* 1. A method declared with a nonnull annotation returns an expression for which
* insufficient nullness information is available for statically proving that no
* flow will pass a null value at runtime.
* 2. An expression for which insufficient nullness information is available for
* statically proving that it will never evaluate to a null value at runtime
* is passed as an argument in a method call where the corresponding parameter of
* the called method is declared with a nonnull annotation.
* 3. An expression for which insufficient nullness information is available for
* statically proving that it will never evaluate to a null value at runtime
* is assigned to a local variable that is declared with a nonnull annotation.
*
* Insufficient nullness information is usually a consequence of using other unannotated
* variables or methods.
*
* 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.
*
* This option only has an effect if the the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id: "org.eclipse.jdt.core.compiler.problem.nullSpecInsufficientInfo"
* Possible values: { "error", "warning", "ignore" }
* Default: "warning"
*
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_PB_NULL_SPECIFICATION_INSUFFICIENT_INFO = PLUGIN_ID + ".compiler.problem.nullSpecInsufficientInfo";
/**
* Compiler option ID: Reporting Redundant Null Annotations.
*
* 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 effective by enabling the option
* {@link #COMPILER_NONNULL_IS_DEFAULT} or by using the annotation specified by the option
* {@link #COMPILER_NONNULL_BY_DEFAULT_ANNOTATION_NAME}.
*
* This option only has an effect if the the option {@link #COMPILER_ANNOTATION_NULL_ANALYSIS} is enabled.
*
* Option id: "org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation"
* Possible values: { "error", "warning", "ignore" }
* Default: "warning"
*
* @since 3.8
* @category CompilerOptionID
*/
public static final String COMPILER_PB_REDUNDANT_NULL_ANNOTATION = PLUGIN_ID + ".compiler.problem.redundantNullAnnotation";
/** * Status constant indicating that the default or specific output folder is overlapping * with another source location. * @since 3.8 */ public static final int OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE = 1013;
/**
* Core option ID: Reporting an output location overlapping another source location.
* Indicate the severity of the problem reported when a source entry's output location overlaps another
* source entry.
*
* Option id:"org.eclipse.jdt.core.classpath.outputOverlappingAnotherSource"
* Possible values:{ "error", "warning", "ignore" }
* Default:"error"
*
* @since 3.8
*/
public static final String CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE = PLUGIN_ID + ".classpath.outputOverlappingAnotherSource";
/** * Description of a bootstrap method table entry as specified in the JVM specifications. * * This interface may be implemented by clients. * * @since 3.8 */ public interface IBootstrapMethodsEntry;
/** * Description of a bootstrap methods attribute as described in the JVM specifications. * * This interface may be implemented by clients. * * @since 3.8 */ public interface IBootstrapMethodsAttribute
/** * Answer back the number of bootstrap methods of this entry as specified in * the JVM specifications. * * @return the number of bootstrap methods of this entry as specified in * the JVM specifications */ int getBootstrapMethodsLength();
/** * Answer back the bootstrap methods table of this entry as specified in * the JVM specifications. Answer an empty array if none. * * @return the bootstrap methods table of this entry as specified in * the JVM specifications. Answer an empty array if none */ IBootstrapMethodsEntry[] getBootstrapMethods();
/** * Description of the new constant pool entry as described in the JVM specifications * added for Java 7 support. * Its contents is initialized according to its kind. * * This interface may be implemented by clients. * * @since 3.8 */ public interface IConstantPoolEntry2
/**
* Returns the descriptor index. This value is set only when decoding a MethodType entry.
* The value is unspecified otherwise. The corresponding UTF8 value can be retrieved by using
* {@link #getMethodDescriptor()}.
*
* @return the descriptor index. This value is set only when decoding a MethodType entry.
* @see IConstantPoolConstant#CONSTANT_MethodType
*/
int getDescriptorIndex();
/** * Returns the reference kind. This value is set only when decoding a MethodHandle entry. * The value is unspecified otherwise. * * @return the reference kind. This value is set only when decoding a MethodHandle entry. * @see IConstantPoolConstant#CONSTANT_MethodHandle */ int getReferenceKind();
/** * Returns the reference index. This value is set only when decoding a MethodHandle entry. * The value is unspecified otherwise. * * @return the reference kind. This value is set only when decoding a MethodHandle entry. * @see IConstantPoolConstant#CONSTANT_MethodHandle */ int getReferenceIndex();
/** * Returns the bootstrap method attribute index. This value is set only when decoding a InvokeDynamic entry. * The value is unspecified otherwise. * * @return the reference kind. This value is set only when decoding a MethodHandle entry. * @see IConstantPoolConstant#CONSTANT_InvokeDynamic */ int getBootstrapMethodAttributeIndex();
/** * @since 3.8 */ void _invokedynamic( int pc, int index, IConstantPoolEntry invokeDynamic);
This has been added in place of the deprecated API
void _invokedynamic( int pc, int index, IConstantPoolEntry nameEntry, IConstantPoolEntry descriptorEntry);
/** * Compiler option ID: Reporting a resource that is not closed properly. * * When enabled, the compiler will issue an error or a warning if * a local variable holds a value of typejava.lang.AutoCloseable(compliance>=1.7) * or a value of typejava.io.Closeable(compliance<=1.6) and if * flow analysis shows that the methodclose()is not invoked locally on that value. * * Option id:"org.eclipse.jdt.core.compiler.problem.reportUnclosedCloseable"* Possible values:{ "error", "warning", "ignore" }* Default:"warning"* * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.unclosedCloseable"; //$NON-NLS-1$
/** * Compiler option ID: Reporting a resource that may not be closed properly. * * When enabled, the compiler will issue an error or a warning if * a local variable holds a value of typejava.lang.AutoCloseable(compliance>=1.7) * or a value of typejava.io.Closeable(compliance<=1.6) and if * flow analysis shows that the methodclose()is * not invoked locally on that value for all execution paths. * * Option id:"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"* Possible values:{ "error", "warning", "ignore" }* Default:"ignore"* * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE = PLUGIN_ID + ".compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$
/** * Compiler option ID: Reporting a resource that is not managed by try-with-resources. * * When enabled, the compiler will issue an error or a warning if a local variable * holds a value of typejava.lang.AutoCloseable, and if the method *close()is explicitly invoked on that resource, but the resource is * not managed by a try-with-resources block. * * Option id:"org.eclipse.jdt.core.compiler.problem.reportPotentiallyUnclosedCloseable"* Possible values:{ "error", "warning", "ignore" }* Default:"ignore"* * @since 3.8 * @category CompilerOptionID */ public static final String COMPILER_PB_EXPLICITLY_CLOSED_AUTOCLOSEABLE = PLUGIN_ID + ".compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$
/** * Returns the binding key of the declaring type of the element represented by this binding key. If the binding key * does not represent a member or if the member doesn't have a declaring type, returnsnull. * * Note that only binding keys for references to methods and fields * are fully supported. The binding keys for declarations will not have type parameters. * * @return the type binding key ornull* @since 3.7.1 */ public BindingKey getDeclaringType();
/** * Returns whether it is safe to use the '<>' (diamond) operator in place of explicitly specifying * type arguments for this proposal. * * This is only relevant for source level 1.7 or greater. * * @param coreContext the completion context associated with the proposal * @since 3.7.1 * @returntrueif it is safe to use the diamond operator for the constructor invocation, *falseotherwise. Also returnsfalsefor source levels below 1.7 */ public boolean canUseDiamond(CompletionContext coreContext);
/** * Compiler option ID: Reporting redundant specification of type arguments in class instance creation expressions. * When enabled, the compiler will issue an error or a warning if type arguments are used in a class instance creation, * when the '<>' operator can be used instead. * * This option only has an effect if the compiler compliance is 1.7 or greater. * * Option id:"org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments"* Possible values:{ "error", "warning", "ignore" }* Default:"ignore"* * @since 3.7.1 * @category CompilerOptionID */ public static final String COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS = PLUGIN_ID + ".compiler.problem.redundantSpecificationOfTypeArguments";
/** * Returnstrueif the resolved class type has been inferred * from the assignment context (JLS4 15.12.2.8),falseotherwise. * * This information is available only when bindings are requested when the AST is being built. * * @returntrueif the resolved class type has been inferred * from the assignment context (JLS3 15.12.2.8),falseotherwise * @since 3.7.1 */ public boolean isResolvedTypeInferredFromExpectedType();
For earlier build notes, also see build notes up to Release 3.7.