• Improve support for Java like languages
  • allow other plug-ins to contribute and participate in search, refactoring as well as code generation and templates
• Improved Java Search
  • searching in background
  • tree based result presentation
• Abstract syntax tree rewriting
• Surface JDK 1.5 features
• Polish and performance work

• [>3.0] Support an IJavaElement adapter in all actions and filters in the same way as the workspace supports an IResource adapter (IAdapter.getAdapter(IJavaElement.class)).
• [>3.0] Support reusing Java editor actions (source and refactoring) in other plug-ins.
• [>3.0] Investigate in IActionFilter support for Java elements (see bug 30948). This is obsolete with the new expression language
• Investigate to use platform's decorator mechanism for error ticks and running man decoration.
• [>3.0] Remove separation between source manipulation actions, refactorings and quick assists.
• Adapt to dynamic plug-in loading (new runtime)
• Allow non-Java partitions in the Java editors.
• Introduce concept of a reconciling pipeline:
  • each element of the pipeline uses the result of the previous
  • mapping between editor content and the several intermediate formats.

• Investigate in customizable hovers in views (like in editor) to show java doc, implementors of method, etc.
• Investigate how to "quick access" source, refactoring and quick assist actions (e.g. not via cascading context menus).
• Simplify filter management in JDT views.
• Investigate use of activities in JDT/UI

• Improve comment handling in AST rewriter.
• [>3.0] Improve sorting capability for compilation units (by visibility, by defining type, ...).
• Enable contributions to code generation templates.

• Smart semicolon, braces, parenthesis in Java code.
• [>3.0] Investigate auto correct in Java code.
• Allow typing actions to be executed in "raw" mode.
• Improve commenting/uncommenting of code.
• [>3.0] Support code completion after <code>Te| or <tt>Te.

• Type hierarchy pop-up for a method. It allows to navigate up and down in the type hierarchy (overrides/ implementors).
• Generalize Type hierarchy pop-up to structured selections in Java views
• Investigate Tab navigator contributions 
• Introduce code folding.
• [>3.0] Present URLs in Javadoc as interactive links.

• Show more outliner information directly in the Java editors.
• Show inherited members in the light-weight outline
• [>3.0] Generalize matching delimiter highlighting to Javadoc tags such as <code> ... </code>.
• Use syntax coloring in source hover.
• Introduce semantic syntax highlighting
• [>3.0] Investigate method separator lines.
• Leverage Platform Text mechanisms to show more information about elements such as all referenced types, call sites, overriders, implementors, declaration (see also Navigation section).
• Support spell checking comments

• Enable the contribution of quick fixes and quick assists.
• Additional quick fixes, e.g., add parameter to existing method, remove unused parameters, convert unused parameter to field.

• Enable other plug-ins to participate in rename, move and delete refactorings.
• Make refactorings Javadoc aware (@see, @link, etc.).
• Enable other plug-ins to contribute new refactorings.
• Publish change infrastructure as API.
• Reduce memory consumption.
• Investigate using type constraints for type related refactorings (extract interface, user supertype, ....).
• Add new refactorings, e.g., add parameter, convert constructor to factory method, extract super class, migrate packages and Java 1.5 specific refactorings.
• Rearchitecture rename, move, delete, cut, copy and paste functionality.
• Improve NLS refactoring

• Allow other plug-ins to participate in Java element searches to find matches in non-Java files (for example JSPs, plugin.xml).
• [>3.0] Add option on the Java Search page to use regular expressions.
• Add option to search in "current" project.
• Improve global search/replace.

• Investigate in user configurable containers.

• Participate in refactoring operations and update test class/package references.
• Enable transition of pde.junit to pde.

• Use of containers to group Java archives in Projects view.

• Support type hierarchy presentation scoped to a working set.

• Adapt to user-oriented preferences.
• [>3.0] Syntax highlighting preview on the preference page should background highlight all occurrences of the selected type.

• How to contribute a quick assist/quick fix

• Regular expression search depends on JDT Core support: 36897
• Javadoc support for refactoring depends on Java doc support in AST.
• Track Changes in other plug-ins
• Platform: templates, consolidated action contribution, snap shotting, background activities, and named sharable preference sets, encoding.
• Platform: Generic navigator
• JDT/Core: JDK 1.5, working copy support, tags in Javadoc, Java elements for local types, and new formatter.

• Polish work
• Finish Java search participants
• Finish refactoring participant API
• Introduce folding

• Inbox tracking (12 days)
• Testing (8 days)

• NLS pass (3 days)
• Provide Javadoc for new API classes (3 days)
• Investigate where we can use more specific scheduling rules to avoid blocking dialogs (2 days)
• Make ZRH components activities aware (2 days)

• Use label decorators to compute override/implements indicator (1 day)
• View initialization in background (1 day)

• Make common expression language dynamic plug-in loadiung aware (2 days)
• Move refactoring into new plug-in org.eclipse.ltk.*.refactoring (10 days)
• Make refactorings more responsive to cancel (1 day)
• Provide code assist in local and field name entry fields (1 day)
• Extract Method: allow destination to be outer class if outer class in non-static (1 day)
• Investigate in better import handling (2 days)
  • remove unused imports for move and inline refactoring
  • don't generate .* imports on move
• Rename (3 days)
  • imporve ripple method computation
  • investigate in hierarchical package rename
• Move (2 days)
  • only show resonable targets in move destination dialog
  • disable reorg moves via refactoring move dialog
• Pull Up (2 days)
  • investigate to run use super type where possible after pull up has completed
  • support pulling up into interfaces

• Use common expression language for Quick fix extension point (1 day)
• New quick fixes: change compiler preferences, add interface to class, change field & method return type (4 days)
• Improve quick fixes for Javadoc errors (1 day)

• Support code generation at cursor location (1 day)
• Investigate in import aware copy & paste (2 days)

• Provide inclusion filter user interface (1 day)
• Investigate moving user library container support into JDT/Core (1 day)

• Finish search participants (3 days)
• Migrate find occurrences to new Search (2 days)
• Provide read/write indication for fields (1.5 days)
• Provide filters for matches in imports, Javadoc, read and write access (3 days)
• Provide an occurrences finder to mark method exit points (1 day)

• Allow headless diff and merge (#54091)
• Allow binding filenames to compare viewers (#51791)
• improve compare support for new sync viewer (#55081, #41564, #52261)
• Show word level diffs using a background color (#54822)

Typing, Presentation, and Source Manipulation

• Provide reconcile with AST support (3 days)
• Override indicators in vertical ruler (3 days)
• Introduce semantic syntax highlighting (10 days)
• Introduce folding in Java editor (10 days)
• Integrate spelling dictionary (3 days)
• Provide proposals for Java template completions (2 days)
• Polish incremental completion mode (1 day)
• Improve Mark Occurrences (3 days)
• Smart typing improvements (5 days)

• Non uniform file encodings (2 days)
  • Provide UI for setting default encoding for files, folders, and projects
• Progress View: (8 days)
  • Improved progress view
  • Local progress indicator for Search

• vacation: 10 days

• Define a CVS connection to server pserver:anonymous@dev.eclipse.org:/home/eclipse,
• Check out HEAD branch of the project org.eclipse.jdt.ui.
• Make sure to import the prerequisite plug-ins (usually from the latest SDK R2.1.x build). Prerequisite plug-ins are already referenced on the project build path ( .classpath file).
• The sources of this project require JDK 1.4.