marks interesting changes since the draft
of Apr. 13, 2005)Please send comments about this draft plan to the eclipse-dev@eclipse.org developer mailing list.
Last revised 16:02 EDT June 10, 2005 (
marks interesting changes since the draft
of Apr. 13, 2005)
Please send comments about this draft plan to the eclipse-dev@eclipse.org
developer mailing list.
This document lays out the feature and API set for the next feature release of Eclipse after 3.0, designated release 3.1.
Plans do not materialize out of nowhere, nor are they entirely static. To ensure the planning process is transparent and open to the entire Eclipse community, we (the Eclipse PMC) post plans in an embryonic form and revise them throughout the release cycle.
The first part of the plan deals with the important matters of release deliverables, release milestones, target operating environments, and release-to-release compatibility. These are all things that need to be clear for any release, even if no features were to change.
The remainder of the plan consists of plan items for the three projects under the Eclipse top-level project. Each plan item covers a feature or API that is to be added to Eclipse, or some aspect of Eclipse that is to be improved. Each plan item has its own entry in the Eclipse bugzilla database, with a title and a concise summary (usually a single paragraph) that explains the work item at a suitably high enough level so that everyone can readily understand what the work item is without having to understand the nitty-gritty detail.
Not all plan items represent the same amount of work; some may be quite large, others, quite small. Some plan items may involve work that is localized to a single Platform component; others may involve coordinated changes to several components; other may pervade the entire Platform. Although some plan items are for work that is more pressing that others, the plan items appear in no particular order.
With the previous release as the starting point, this is the plan for how we will enhance and improve it. Fixing bugs, improving test coverage, documentation, examples, performance tuning, usability, etc. are considered routine ongoing maintenance activities and are not included in this plan unless they would also involve a significant change to the API or feature set, or involve a significant amount of work. The intent of the plan is to account for all interesting feature work.
The current status of each plan item is noted:
The release deliverables have the same form as previous releases, namely:
Release milestone occurring at roughly 6 week intervals exist to facilitate coarse-grained planning and staging. The milestones are:
Lock down and testing
then begins with M7, and progress through a series of test-fix passes against
candidates releases. Release candidate builds are planned as follows (M7 is
release candidate 0):
Depending on the circumstances, we may add additional release candidate builds or fine-tune the schedule. The 3.1 release is targeted for the week of June 27, 2005. See the Eclipse 3.1 Endgame Plan for further details. All release deliverables will be available for download as soon as the release has been tested and validated in the target operating configurations listed below.
In order to remain current, each Eclipse release targets reasonably current versions of the underlying operating environments.
Most of the Eclipse SDK is "pure" Java™ code and has no direct dependence on the underlying operating system. The chief dependence is therefore on the Java 2 Platform itself. The 3.1 release of the Eclipse Project is written and compiled against version 1.4 of the Java 2 Platform APIs, and targeted to run on version 1.4 of the Java 2 Runtime Environment, Standard Edition.
There are many different implementations of the Java 2 Platform running atop a variety of operating systems. We focus Eclipse testing on a handful of popular combinations of operating system and Java 2 Platform; these are our reference platforms. Eclipse undoubtedly runs fine in many operating environments beyond the reference platforms we test. However, since we do not systematically test them we cannot vouch for them. Problems encountered when running Eclipse on non-reference platform that cannot be recreated on any reference platform will be given lower priority than problems with running Eclipse on a reference platform.
Eclipse SDK 3.1 is tested and validated on the following reference platforms (this list is updated over the course of the release cycle):
|
Eclipse Reference Platforms
|
|||
|---|---|---|---|
| Operating system | Processor architecture | Window system | Java 2 Platform |
| Microsoft Windows XP | Intel x86 | Win32 | Sun Java 2 Standard Edition, version 1.4.2_08 for Microsoft Windows |
| Microsoft Windows XP | Intel x86 | Win32 | IBM 32-bit SDK for Windows, Java 2 Technology Edition, Version 1.4.2 SR1a |
| Microsoft Windows XP | Intel x86 | Win32 | Sun Java 2 Standard Edition 5.0 Update 2 for Microsoft Windows |
| Red Hat Enterprise Linux WS 3 | Intel x86 | GTK | Sun Java 2 Standard Edition, 1.4.2_08 for Linux x86 |
| Red Hat Enterprise Linux WS 3 | Intel x86 | GTK | IBM 32-bit SDK for Linux on Intel architecture, Java 2 Technology Edition, Version 1.4.2 SR1a |
| SLES 9 | Intel x86 | GTK | Sun Java 2 Standard Edition, version 1.4.2_08 for Linux x86 |
| SLES 9 | Intel x86 | GTK | IBM 32-bit SDK for Linux on Intel architecture, Java 2 Technology Edition, Version 1.4.2 SR1a |
| Sun Solaris 8 | SPARC | Motif | Sun Java 2 SDK, Standard Edition, 1.4.2_08 for Solaris SPARC |
| HP HP-UX 11i | hp9000 PA-RISC |
Motif | HP-UX SDK for the Java 2 platform, version 1.4.2.07 for hp9000 PA-RISC |
| IBM AIX 5L Version 5.2 | PowerPC | Motif | IBM 32-bit SDK for AIX, Java 2 Technology Edition, Version 1.4.2 SR1a |
| Apple Mac OS X 10.3 | PowerPC | Carbon | Java 2 Standard Edition 1.4.2 for Mac OS X |
Although untested, Eclipse should work fine on other OSes that support the same window system. For Win32: Windows 98, ME, NT, 2000, and Server 2003; SWT HTML viewer requires Internet Explorer 5 (or higher). For GTK on other Linux systems: version 2.2.1 of the GTK+ widget toolkit and associated librares (GLib, Pango); SWT HTML viewer requires Mozilla 1.4GTK2. For Motif on other Linux systems: Open Motif 2.1 (included); SWT HTML viewer requires Mozilla 1.4GTK2.
An early access version of Eclipse is also available for 64-bit Linux GTK. Testing has been limited to early access 64-bit J2SEs running on x86-64 processors.
SWT is also supported on the QNX Neutrino operating system, x86 processor, Photon window system, and IBM J9 VM version 2.0. Eclipse 3.1 on Windows or Linux can be used cross develop QNX applications. (Eclipse 3.1 is unavailable on QNX because there is currently no 1.4 J2SE for QNX.)
The Eclipse Platform is designed as the basis for internationalized products. The user interface elements provided by the Eclipse SDK components, including dialogs and error messages, are externalized. The English strings are provided as the default resource bundles.
Latin-1 locales are supported by the Eclipse SDK on all of the above operating environments; DBCS locales are supported by the Eclipse SDK on the Windows, GTK, and Motif window systems; BIDI locales are supported by the Eclipse SDK only on Windows operating environments.
The Eclipse SDK supports GB 18030 (level 1), the Chinese code page standard, on Windows XP and 2000, and Linux.
German and Japanese locales are tested.
SWT fully supports BIDI
on Windows (only). On Linux GTK, SWT supports entering and displaying BIDI text.
The widget orientation of JFace windows defaults appropriately in BIDI locales
on all platforms.
The Eclipse SDK is a development environment targeted at technical professionals - not an end user application. However, the Eclipse SDK tools will permit technical professionals who are working in English to build Hebrew/Arabic end user Java programs which are themselves not based on the Eclipse SDK. The BIDI support in the Eclipse SDK allows a Java programmer to work with BIDI strings, code comments, etc. but the Eclipse SDK itself is not designed to be localized for BIDI locales and its widget orientation can not be changed.
Eclipse 3.1 will be compatible with Eclipse 3.0.
API Contract Compatibility: Eclipse SDK 3.1 will be upwards contract-compatible with Eclipse SDK 3.0 except in those areas noted in the Eclipse 3.1 Plug-in Migration Guide. Programs that use affected APIs and extension points will need to be ported to Eclipse SDK 3.1 APIs. Downward contract compatibility is not supported. There is no guarantee that compliance with Eclipse SDK 3.1 APIs would ensure compliance with Eclipse SDK 3.0 APIs. Refer to Evolving Java-based APIs for a discussion of the kinds of API changes that maintain contract compatibility.
Binary (plug-in) Compatibility: Eclipse SDK 3.1 will be upwards binary-compatible with Eclipse SDK 3.0 except in those areas noted in the Eclipse 3.1 Plug-in Migration Guide. Downward plug-in compatibility is not supported. Plug-ins for Eclipse SDK 3.1 will not be usable in Eclipse SDK 3.0. Refer to Evolving Java-based APIs for a discussion of the kinds of API changes that maintain binary compatibility.
Source Compatibility: Eclipse SDK 3.1 will be upwards source-compatible with Eclipse SDK 3.0 except in the areas noted in the Eclipse 3.1 Plug-in Migration Guide. This means that source files written to use Eclipse SDK 3.0 APIs might successfully compile and run against Eclipse SDK 3.1 APIs, although this is not guaranteed. Downward source compatibility is not supported. If source files use new Eclipse SDK APIs, they will not be usable with an earlier version of the Eclipse SDK.
Workspace Compatibility: Eclipse SDK 3.1 will be upwards workspace-compatible with Eclipse SDK 3.0 unless noted. This means that workspaces and projects created with Eclipse SDK 3.0 can be successfully opened by Eclipse SDK 3.1 and upgraded to a 3.1 workspace. This includes both hidden metadata, which is localized to a particular workspace, as well as metadata files found within a workspace project (e.g., the .project file), which may propagate between workspaces via file copying or team repositories. Individual plug-ins developed for Eclipse SDK 3.1 should provide similar upwards compatibility for their hidden and visible workspace metadata created by earlier versions; 3.1 plug-in developers are responsible for ensuring that their plug-ins recognize 3.1, 3.0, 2.1, and 2.0 metadata and process it appropriately. User interface session state may be discarded when a workspace is upgraded. Downward workspace compatibility is not supported. A workspace created (or opened) by a product based on Eclipse 3.1 will be unusable with a product based an earlier version of Eclipse. Visible metadata files created (or overwritten) by Eclipse 3.1 will generally be unusable with earlier versions of Eclipse.
Non-compliant usage of API's: All non-API methods and classes, and certainly everything in a package with "internal" in its name, are considered implementation details which may vary between operating environment and are subject to change without notice. Client plug-ins that directly depend on anything other than what is specified in the Eclipse SDK API are inherently unsupportable and receive no guarantees about compatibility within a single release much less with an earlier releases. Refer to How to Use the Eclipse API for information about how to write compliant plug-ins.
The changes under consideration for the next release of Eclipse Platform, JDT, and PDE address major themes identified by the Eclipse Requirements Council. (The theme synopses here are cut down versions of the ones in Eclipse Requirements Council: Themes and Priorities dated Dec. 15, 2004 - pdf). The themes are not in priority order.
In addition, there are a few important Eclipse Platform improvements that do not naturally fit into any of the above themes.
Each of the 3 projects under the Eclipse top-level project is covered in its own section:For each project, the items listed reflect new features of Eclipse or areas where existing features will be significantly reworked. Each item indicates the components likely affected by that work item (many items involve coordinated changes to several components). Numbers in parentheses link to bugzilla problem reports for that plan item.
The Eclipse Platform provides the most fundamental building blocks. Plan items reflect new features of the Eclipse Platform, or areas where existing features will be significantly reworked.
Mapping logical views to physical files on disk. In some cases, multiple distinct objects happen to be stored in a single file, like an archive. Conversely, in other cases, something that is logically a single object is stored across multiple files. This discrepancy between logical and physical creates problems for common operations such as searching, comparing, and versioning, which need to work in the physical realm. Eclipse should support some way of mapping between a logical view and the physical organization of files on disk. [Platform Core, Platform UI, Team] (80396 ) [Theme: Design for Extensibility]
Work completed (Follow-on work is planned for the next release.)
Large-scale workspaces. Some large customers have workspaces containing several hundred projects. Scoped builds (added in 3.0) were a step in the right direction towards making these workable. Eclipse needs to provide appropriate support for large workspaces and working sets, and ensure that everything scales properly. [Platform Core; Platform UI; JDT] (71128) [Theme: Scaling Up]
Process improvements wrt performance. For 3.1 we should get a firm grip on speed and space performance. To do this we should (1) identify which aspects are critically important performance-wise; (2) establish benchmarks to quantify performance; and (3) look at ways to improve performance. By its nature, it's hard to say in advance what kind of improvements we'll be able to achieve, making it difficult to make performance improvements a release deliverable. Instead, what we need to do for 3.1 is commit to track performance from this point on. We should carry out performance reviews (1) and create benchmarks (2) for every component, and for any critical aspects that span components. Even if we cannot find ways to make significant performance gains (3), the benchmarks are still critical to Eclipse's success to prevent backsliding in the future. The work item is to improve our process with respect to performance. The deliverables are the automated performance tests, the build process that collects and publishes performance data covering all critical aspects of Eclipse, and the commitment to leverage this data to monitor speed and space performance as part and parcel of developing Eclipse. [All Eclipse components] (71123) [Theme: Scaling Up]
Overhaul preferences. The way that Eclipse deals with preferences should be improved. The workbench presentation of preferences generally uses a component-oriented hierarchy, which is not always the best choice for users. The UI should present preferences in such a way that users can readily discover them. Some preference settings have scopes (e.g., workspace-wide vs. per project). The UI should help the user to visualize these scopes. For team-wide uniformity, some preferences settings (e.g., compiler options) need to be shared (or imposed) across teams. The UI should also facilitate this. [Platform Core; Platform UI; Text; JDT UI; JDT Core] (71124) [Theme: Simple to use]
Improve action contributions. Simplify the programming model for contributing menu and toolbar items to the workbench (and their corresponding appearance and behavior). Improve control over menu definition and item ordering. Allow the selected object in a view to override an action, e.g., Rename menu item on Java element in navigator view resolves to JDT refactoring rename instead of basic file rename. Maintain a strong separation between a command, its handler(s) and its placement(s) in the UI. [Platform UI; Platform Text; JDT UI] (36968) [Theme: Design for Extensibility]
Scalability. In cases where either the target machine is resource-constrained, or the number of plug-ins is large, or the size of the workspace is large, the scalability of the Eclipse Platform is especially important. The work involves identifying problematic areas and making changes to improve the scalability. [All components] (80129) [Theme: Scaling Up]
Improve capabilities. Eclipse 3.0 introduced the notion of capabilities and provided categories for grouping related capabilities. These capabilities are used to simplify the UI by hiding functionality that is not currently relevant to the user. This plan item is to improve this support. The missing features center around a product's ability to successfully support higher-level notions (like user roles) and control when and how capabilities get enabled. [Platform UI] (80130) [Theme: Simple to use]
Ant editor improvements. Provide the Ant editor with comparable functionality to the Java editor with regard to folding, hyperlink navigation, open declaration, marking occurrences, show external documentation, refactoring, etc. [Ant] (80135) [Theme: Simple to use]
Breakpoint improvements. Simplify debugging with lots of breakpoints: provide different ways to group and organize breakpoints so that they can be enabled/disabled as a unit. [Debug] (80136) [Theme: Scaling Up]
Generalized undo support. The Platform should define a common command processing framework in order to provide a workbench-wide undo/redo facility. [Platform UI; Platform Text; JDT UI] (80137) [Theme: Design for Extensibility]
Content types. The algorithm that the Eclipse Platform uses to determine which editor to open is based on the file's name and simple matching rules. In many cases like XML files this simple approach is not sufficient. The Platform needs to provide a more robust and scalable solution based on the content of the resource. [Platform UI] (37668) [Theme: Design for Extensibility]
Add critical performance instrumentation. Add support for monitoring performance and detecting problems in performance critical aspects of the Eclipse Platform. Potential critical areas to monitor include the times to: start up a plug-in, open an editor, display a menu, switch perspectives, process an SWT event, process a resource change event, etc. [Platform UI; Platform Core; SWT] (80138) [Theme: Scaling up]
Initial user experience improvements. Support for Welcome content will be enhanced by a number of improvements: authoring of welcome content will be made easier by providing easy preview of the resulting pages when all the content is composed; whenever possible, help documents will be shown in place to reduce the need to leave the Welcome context; transition to workbench will be made less abrupt with various degrees of welcome still present for the user to return; support for welcome in sophisticated stacked products will be enhanced. [Platform UI] (80139) [Theme: Simple to use]
Help search enhancements. Search will be enhanced in a number of ways. Add the ability to search the web in addition to local documentation, and to collate results from multiple search engines queried in parallel. Improve the presentation of search by exposing Help searches in wizard UI panes, and by making search pervasive in the workbench. [Help, Platform UI, Search] (80131) [Theme: Design for Extensibility; Simple to Use]
Pervasive context help pane. The Platform should provide a reusable pane to show context help for the currently active context. The pane can be used in various places, including views and wizard dialogs. The pane shows additional help on the current context, links to help topics about it, and a quick search entry. [Help, Platform UI] (80143) [Theme: Simple to use]
RCP performance. Startup time and total space requirements are key elements in the viability of Eclipse as an RCP. In the 3.1 cycle we will focus on these two performance characteristics with the particular goals of: reducing space required internal data structures (e.g., framework state, extension registry, ...); streamlining the startup execution to get to the application code faster; and providing basic support for space-efficient resource bundles. [Platform Core] (80145) [Theme: Rich Client Platform; Scaling Up]
RCP infrastructure. There are various improvements to the RCP infrastructure to better support a widening range of uses, including: improve support for preconfigured installs; and improve support for API declaration/consumption. Additionally, all RCP-related plug-ins will be updated to use only classes in the J2ME CDC/Foundation profile. [Platform Core; Platform UI; Update; Help] (80146) [Theme: Rich Client Platform]
OSGi. Eclipse 3.1 will include a compliant implementation of the upcoming OSGi Platform R4 specification. We will also increase the flexibility of the adaptor structure of the OSGi framework in order to make it easier to use the Eclipse OSGi implementation on its own. [Platform Core] (80147) [Theme: Rich Client Platform]
Dynamic plug-ins. In Eclipse 3.0 it became possible to install and remove plug-ins without restarting the system. In practice this is a cooperative effort requiring the rest of the plug-ins in the system to respond correctly to the changes. Work will be done to increase the runtime support for making plug-ins dynamic-aware, including annotating plug-ins with their dynamic characteristics, changing the registry data structure to use light-weight handles, and provide support for tracking key objects. Other RCP plug-ins will be updated to use these mechanisms. Also, develop reusable coding structures and guidelines for writing dynamic-aware plug-ins. [Platform Core; Platform UI; Platform Text; Update; Help] (80148) [Theme: Rich Client Platform]
JNLP Support. It is convenient to be able to launch a Java-based application from a web browser. There are various technical issues with launching Eclipse using Java Web Start (JNLP). We will ensure that the simple forms of JNLP-based deployment are supported, and will investigate supporting more advanced solutions that could provide a higher level of integration between the Eclipse component model and that of JNLP. [Platform Core] (80149) [Theme: Rich Client Platform]
Support for launcher branding. A key step in producing an RCP-based product is creating the launcher the user uses to run the product. As a minimum it should have a product-specific name and icon. Currently, constructing such a launcher requires a C compiler and other OS-specific tools. We will investigate providing template launchers which can be instantiated by PDE when assembling a product for a given OS. [SWT; PDE] (80150) [Theme: Rich Client Platform]
Ant debugger. Provide an integrated debugger for Ant build files. [Ant] (80151)
Provide better text editor support for RCP. The following functions were added: pluggable spell checking, URL detection and handling. [Platform Text] (80154) [Theme: Rich Client Platform]
None at this time.
Embedding editors and views. Various plug-ins encounter problems when trying to embed editors or views within other workbench parts. For example, the current compare infrastructure requires a plug-in to create a separate text editor for viewing changes between files. This is due to a limitation in the workbench that prevents editors from being embedded inside views or other controls. As a consequence, the compare editor's nested editors don't support the full set of features provided by the corresponding real content-type-specific editor. This represents a major usability problem: the user must switch to the real editor to make changes and then return to the compare view to review the changes. Eclipse should be more flexible in the ways various editors can be used and reused. Improve the UI component model to support nesting of workbench parts. Reduce coupling of parts to particular locations in the workbench, allowing for more flexible UI configurations. [Platform UI, Compare, Platform Text] (71125) [Theme: Design for Extensibility]
Security. Support ongoing work in Equinox investigating security. This covers items such as enabling Java 2 security managers, plug-in signing, techniques and mechanisms for authentication and authorization and credential stores as well as end-to-end security of the Platform install. [Platform Core; Platform Update] (37692) [Theme: Rich Client Platform]
Team policies. Teams of developers working together have special needs for ensuring the integrity and consistency of their collective work. For example, they may have policies for things like source file naming, code formatting, or bug report number for change tracking. Eclipse should enable tools that help achieve that integrity and consistency. Eclipse should provide more access points so that complex policies can be suggested, checked, or enforced. [Platform Core; Team] (71126) [Theme: Enterprise Ready]
Provide better text editor support for RCP. The list of functions to add will grow over time. The initial set includes: annotation presentation and navigation, user assigned colors and fonts, enable spell checking in non-Java editors, user defined persistent folding, quick diff, templates. [Platform Text] (80154) [Theme: Rich Client Platform]
Macro recording and playback. Add a mechanism for recording a sequence of user interface interactions, storing then in a file, and playing them back at a later time. File playback will be made available as an action for the benefit of cheat sheets and active help. [Platform UI] (80140) [Theme: Simple to use]
Improve cheat sheet authoring. The goal is to better support authoring of cheat sheets by non-programmers by allowing actions to be recorded as macros to handle 'do it for me' step actions. [Platform UI] (80142) [Theme: Simple to use]
Enhancements for supporting new users. Following on from the work done in Eclipse 3.0, we want to further improve the way Eclipse feels to new users. For example: support for templates (to create projects that do something useful) as well as a set of templates that ship with Eclipse SDK; support for samples (enhancing sample support shipped in 3.0 and making it API); safe mode (a constrained mode of running the workbench - 'training wheels' - where capabilities are restricted in order to prevent common early mistakes); simpler workspace chooser (where do you want your work saved?); more usable perspective chooser with short description, a small image that shows the general perspective layout, perspective groups by role e.g. Java Development. [Platform UI] (80132) [Theme: Simple to use]
Help system improvements. A number of improvements would be added to the current help system to address the current problems and make help more useful. Improvements include: Allow help content to appear embedded in various places of the workbench (welcome, cheat sheets, help view) as a way to avoid problems caused by having all Help presented in a separate window (this would also entail some rework of the Tasks sections of the Eclipse help books to make them suitable for presentation in a narrow window). Provide a hook from error dialogs into help. [Help] (80141) [Theme: Design for Extensibility; Simple to Use]
Concurrency support for debuggers. Many debug architectures require communicating with a remote debug target. The debug user interface needs to be robust in the face of latent and unreliable connections. To avoid blocking the user interface, the debug platform will use background jobs to perform operations and communicate with debuggers. [Platform Debug, JDT Debug] (80152) [Theme: Design for Extensibility]
(End of items for Eclipse Platform project.)
Java development tools (JDT) implements a Java IDE based on the Eclipse Platform. The following work items reflect new features of JDT, or areas where existing features will be significantly reworked.
Add support for J2SE 5 features. J2SE 5 (also known as JDK 1.5 "Tiger") shipped in September 2004. This release contains new Java language features, including generic types, typesafe enumerations, autoboxing, enhanced for loops, static imports, varargs, and annotations. Supporting these new language and compiler features requires major changes to the Eclipse Java compiler, to JDT Core APIs, to JDT UI, and to JDT Debug. Eclipse should contain full support for developing Java programs that use the new language features, including code assist, quick fixes, new wizards, source actions, and refactorings. There should also be quick assists and refactorings for migrating existing Java code to the new language constructs, including inferring type parameters for Collections, and converting simple for loops to use the enhanced for loop. [JDT Core, JDT UI, JDT Text, JDT Debug] (36938) [Theme: Appealing to the Broader Community]
Improved compiler checking. Add support for detecting references to internal classes; add warnings about missing declarations of serialVersionUID, incomplete enum switches, boxing and unboxing conversions, and type parameter declaration hiding. [JDT Core] (80155)
Improve support for externalized strings. Provide a separate properties file editor, and enhance the Java editor to display the value of and navigate from an NLS key in code and the corresponding entry in the properties file. [JDT Text] (80156)
Debugger usability improvements. Integrate monitor locks into the debug view, show variable values inline, support hyperlink-style navigation from the text of any stack trace. [JDT Debug; Platform Debug] (80158) [Theme: Simple to use]
Import/export of Ant build files. Using information from the javac task in an existing Ant build file, create a Java project, import the source files, and configure the project's build class path. Conversely, from an existing Java project generate an Ant build file that will compile the project's source files. [JDT UI; Ant] (80159) [Theme: Enterprise Ready]
Improve program manipulation infrastructure. Parts of the Java model are still implemented in terms of the deprecated JDOM, an early precursor of the AST facility. JDT should move to an AST-based implementation of the Java model. All source and refactoring operations should be rewritten to use common program manipulation infrastructure based on ASTs and AST rewriting. There should also be better support for navigating between a node in an AST (or an AST binding) and the corresponding element in the Java model (which would benefit views that present type hierarchies). [JDT Core, JDT UI] (71129)
Expose Java editor functionality. Make functionality currently found in the Java editor available to other plug-ins by pushing it down into Platform Text. The commited portion includes hyperlink style navigation and configurable spell checking engine. [JDT Text; Platform Text] (80157) [Theme: Design for Extensibility]
None at this time.
Expose Java editor functionality. Make functionality currently found in the Java editor available to other plug-ins by pushing it down into Platform Text. The deferred portion includes annotation navigation, spell checking, and quick fix infrastructure. [JDT Text; Platform Text] (80157) [Theme: Design for Extensibility]
Improve program manipulation infrastructure. AST creation in the presence of syntax errors should be improved to include partial bindings. The goal is to support statement level recovery in the AST parser. The performance of AST creation should be improved by using a special parser and eliminating one internal layer of ASTs. [JDT Core, JDT UI] (71129)
Library projects. For plug-in development, PDE distinguishes between the plug-in projects you are working on (source plug-in projects) and plug-in projects you are working with but not actually changing (binary plug-in projects). Making this distinction afforts the user the benefits of having full source for everything in their workspace where it's easily browsed and searched, while permitting economies because the latter kind of projects do not actually have to be (re)compiled. This work item is to support a similar notion of library project for Java development in general. The user would be able to flag a Java project as a library project; JDT would know how present library projects appropriately at the UI, and how to deal with them more efficiently using generated binaries. [JDT Core, JDT UI] (80162) [Theme: Design for Extensibility]
Search enhancements. Provide additional search queries to enable more precise searching; e.g., find where is a exception thrown/caught, match against method parameters in reference searches. [JDT Core, JDT UI] (71130)
(End of items for Eclipse JDT project.)
RCP support. PDE currently supports developing Eclipse plug-ins, but is not expressly geared for the specific needs of clients developing applications based on the RCP. PDE should facilitate developing and deploying RCP-based applications. (71131) [Theme: Rich Client Platform]
OSGi bundle manifest tooling. In OSGi, bundles are defined using standard JAR manifest.mf files. PDE 3.0 contains a rudimentary manifest editor. This support will be expanded in 3.1 to include support for import/export package, increased dependency validation, and tools for "bundlizing" third-party non-Eclipse JARs. [PDE] (80165) [Theme: Rich Client Platform]
None at this time.
Improved target support. PDE manages a model of the target Eclipse for which you are developing. These targets may be complex and diverse and switching targets or launch configurations can be expensive. PDE will be extended to support named targets, and automatically track changes to the workspace affecting targets. [PDE] (80163) [Theme: Rich Client Platform]
(End of items for Eclipse PDE project.)