jdt core - build notes 3.6 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.6 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.5 (also see a summary of API changes).
Maintenance of previous releases of JDT/Core is performed in parallel branches: 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. |
/** * Returns a Java search scope limited to the hierarchy of the given type and to a given project. * The Java elements resulting from a search with this scope will be types in this hierarchy. * * Unlike the createHierarchyScope methods, this method creates strict * scopes that only contain types that actually span the hierarchy of the focus * type, but do not include additional enclosing or member types. * * * By default, hierarchy scopes include all direct and indirect supertypes and subtypes of the * focus type. This method, however, allows to restrict the hierarchy to true subtypes, * not including supertypes. Also inclusion of the focus type itself is controled by a parameter. * * * @param project the project to which to constrain the search, or null if * search should consider all types in the workspace * @param type the focus of the hierarchy scope * @param onlySubtypes if true only subtypes of type are considered * @param includeFocusType if true the focus type type is included in the resulting scope, * otherwise it is excluded * @param owner the owner of working copies that take precedence over original compilation units, * or null if the primary working copy owner should be used * @return a new hierarchy scope * @exception JavaModelException if the hierarchy could not be computed on the given type * @since 3.6 */ public static IJavaSearchScope createStrictHierarchyScope(IJavaProject project, IType type, boolean onlySubtypes, boolean includeFocusType, WorkingCopyOwner owner) throws JavaModelException;
org.eclipse.jdt.core.compiler.IProblem.UnusedObjectAllocation /** * Compiler option ID: Reporting Allocation of an Unused Object. * When enabled, the compiler will issue an error or a warning if an object is allocated but never used, * neither by holding a reference nor by invoking one of the object's methods. * * Option id:"org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation" * Possible values:{ "error", "warning", "ignore" } * Default:"ignore" * * @since 3.6 * @category CompilerOptionID */ public static final String COMPILER_PB_UNUSED_OBJECT_ALLOCATION = PLUGIN_ID + ".compiler.problem.unusedObjectAllocation";
/** * Returns the reconcile flag of this context. This flag is a bitwise value of the constant defined * in ICompilationUnit. * * @return the reconcile flag of this context * @since 3.6 * * @see ICompilationUnit#ENABLE_BINDINGS_RECOVERY * @see ICompilationUnit#ENABLE_STATEMENTS_RECOVERY * @see ICompilationUnit#IGNORE_METHOD_BODIES */ public int getReconcileFlags();
TypeNameMatch
:
/** * Returns the accessibility of the type name match * * @see IAccessRule * * @return the accessibility of the type name which may be * {@link IAccessRule#K_ACCESSIBLE}, {@link IAccessRule#K_DISCOURAGED} * or {@link IAccessRule#K_NON_ACCESSIBLE}. * The default returned value is {@link IAccessRule#K_ACCESSIBLE}. * * @since 3.6 */ public abstract int getAccessibility();See bug 296277 for more details.
org.eclipse.jdt.core.dom.ASTParser: /** * Requests an abstract syntax tree without method bodies. * * When ignore method bodies is enabled, all method bodies are discarded. * This has no impact on the binding resolution. * * If a method contains local types, its method body will be retained. * This settings is not used if the kind used in setKind(int) is either * K_EXPRESSION or K_STATEMENTS. * @since 3.5.2 */ public void setIgnoreMethodBodies(boolean enabled); org.eclipse.jdt.core.ICompilationUnit: /** * Constant indicating that a reconcile operation could ignore to parse the method bodies. * @see ASTParser#setIgnoreMethodBodies(boolean) * @since 3.5.2 */ public static final int IGNORE_METHOD_BODIES = 0x08;
org.eclipse.jdt.core.JavaCore
in order to fix bug 263564:
/** * Returns an immutable map of all known configurable options with their original default values * as defined by JDT/Core. * * The values of these options might be different from the values returned by getDefaultOptions() * as getDefaultOptions() returned the default options defined by an installation/product/configuration * (i.e. modified by the usage of a plugin_customization.ini file for example). * * These options allow to configure the behaviour of the underlying components. * If the map is being modified, an UnsupportedOperationException> exception is thrown. * Helper constants have been defined on JavaCore for each of the option IDs * (categorized in Code assist option ID, Compiler option ID and Core option ID) * and some of their acceptable values (categorized in Option value). Some * options accept open value sets beyond the documented constant values. * Note: each release may add new options. * * @return an immutable map of all known configurable options with their original default values * as defined by JDT/Core * @since 3.6 */ public static Map getOriginalDefaultOptions();
invokedynamic
bytecode:
org.eclipse.jdt.core.util.ByteCodeVisitorAdapter: public void _invokedynamic( int pc, int index, IConstantPoolEntry nameEntry, IConstantPoolEntry descriptorEntry) { // default behavior is to do nothing }
org.eclipse.jdt.core.util.IBytecodeVisitor#_invokedynamic(int, int, IConstantPoolEntry, IConstantPoolEntry)
org.eclipse.jdt.core.util.IOpcodeMnemonics#INVOKEDYNAMIC
For earlier build notes, also see build notes up to Release 3.5.