Platform | |
Workers use job names as thread names |
The jobs framework now uses Job names for Worker thread names. Previously all
running Worker 's got enumerated thread names, without any hint what the
current Worker is actually doing:
Now the Job name is added
next to the Worker name:
|
JDT | |
Debugger listens to thread name changes |
Debug view now automatically updates thread names if they are changed in the debuggee JVM.
This shows live information for worker instances, as described above.
Technically speaking, Java debugger automatically adds a new (user invisible) breakpoint in the JVM and notifies clients (like Debug view) on a breakpoint hit. If this behavior is undesired for some reason, product owners can disable it via product customization.
The property value is:
|
Navigate to 'switch' statement |
You can now Ctrl+click or use Open Declaration (F3) on case or default
keywords to quickly navigate to the beginning of the switch statement.
|
Paste module-info.java code in Package Explorer |
You can now paste a snippet of code representing module-info.java directly into a source folder to create a module-info.java file.
For example, copy this code:
import java.sql.Driver; module hello { exports org.example; requires java.sql; provides Driver with org.example.DriverImpl; }Then select a source folder in a Java 9 project in the Package Explorer view and use Ctrl+V (Edit > Paste) to paste it. This automatically creates a module-info.java file in the source folder with the copied content. |
Content assist for module declaration name | Content assist (Ctrl+Space) support is now available for module declaration name. |
New formatter profile page |
The formatter profile preference page (Java > Code Style > Formatter > Edit...) has a new look which
makes it much easier to set preferences for formatting Java code. Instead of multiple tabs, all preferences are
presented in an expandable tree.
You can use filtering to display only settings with names matching a specific phrase. Filtering by values is also possible (prefix a value filter with a tilde). Most sections have a "Modify all" button in their header that lets you set all their preferences to the same value with one click. Some preferences have more convenient controls. For example, number values can be easily modified with arrow buttons. Wrap policy settings are controlled by simple toolbars so that you can see and compare multiple policies at once. In the preview panel you can now use your own code to immediately see how it will be affected by the modified settings. You can also see the raw form of standard preview samples and make temporary modifications to them. |
Test sources |
In the Java Build Path project settings, there is now an attribute Contains test sources to configure
that a source folder contains test sources (Note: test sources must have their own output folder). Similar, for
projects and libraries there is an attribute Visible only for test sources. This setting also exists for
classpath containers, and if it is set to Yes for one of these, this value will be used for all contained
libraries and projects.
Test source folders and dependencies are shown with a darker icon in the build path settings, the package explorer and other locations. This can be disabled in Preferences > Java > Appearance: Referenced projects can contain test sources and have test dependencies themselves. Usually, when test sources are compiled, the test code in projects on the build path will be visible. As this is not always desirable, it can be changed by setting the new build path attribute Without test code, that is available for projects, to Yes. Build path entries configured like this have a decoration For each project, compilation is now done in two phases: First all main sources (which cannot see any test-code on the build-path) and then all test sources. As a consequence, if the project is a modular Java 9 project, test dependencies like JUnit can not be referenced in
the Of course, code completion will not suggest test code in main sources: There are now two dynamic Java working sets Java Main Sources and Java Test Sources containing the source folders grouped according to value of the Contains test sources attribute. This can for example be used to remove warnings in test sources from the problems view: To achieve this, create a new filter that shows warnings for the Java Main Sources working set and select it with the All Errors on Workspace filter: There are also dedicated filters to quickly remove hits in main code or test code from Java search results: Similar, there is a filter to remove test code from Call hierarchies: Another filter to remove test code exists for Quick type hierarchies: Test source folders will be preselected in the New JUnit Test Case-Wizard In Run and Debug configurations, the Classpath tab (or Dependencies tab when launching with Java 9) contains a new option Exclude Test Code, that is automatically preselected when launching a Java Application from a source folder that is not marked to contain test sources: When launching with Java 9 and this option is not selected, command line options will automatically be added so modules that have a non-empty classpath read the unnamed module. These command line options are part of what can be overridden using the new Override Dependencies button. |
Value displayed for method exit and exception breakpoints |
When a method exit breakpoint is hit, the value being returned is now shown in the variables view.
Similar, when an exception breakpoint is hit, the exception being thrown is shown. |
Display view now named Debug Shell |
The Display view has been renamed to Debug Shell to better match the features and purpose of this feature.
A line of Java comment have also been added to the view on fresh open to encourage trying it further.
|
Overriding modular build path dependencies for launching |
Based on Java build path, a Java 9 module can have command line options. These options from build path can be overridden for launching programs in the module.
Override Dependencies button has been added to Dependencies tab:
Dialog can be used to override modular dependencies:
|
Launch configuration prototypes for Java Launch Configurations |
A Java Launch Configuration can now be based on a prototype.
A prototype seeds attributes in its associated Java Launch Configurations with the settings specified in the Prototype tab. Once a Java Launch Configuration has been created, you can override any initial settings from the prototype. You can also reset the settings of a Java Launch Configuration with the ones from its prototype. A Java Launch Configuration maintains a link to its prototype, but is a complete stand-alone launch configuration than can be launched, exported, shared, etc.
|
Option for Regex in Module Declaration Search |
This is an experimental support provided to allow the regular expression usage in search field while searching for module declaration.
This can be considered as a wrapper of the API change. To invoke the regular expression search from
the search field under Java Search, start the expression with "/r " ie a slash '/', the letter 'r' and a blank ' ' (not tab)
followed by a regex, an example of which is shown below:
In the above example, all the characters trailing "/r " form a Java regular expression to denote a module name which starts with zero or more 'n's followed by the string ".ver" and followed again by zero or more number of arbitrary characters.
Another example would be to search for all modules that start with |
@NonNullByDefault per module |
If a module is annotated with @NonNullByDefault , the compiler will interpret this
as the global default for all types in this module:
@org.eclipse.jdt.annotation.NonNullByDefault module my.nullsafe.mod { ...
Note, however, that this requires an annotation type declared with target |
PDE | |
PDE handles generic bundle requirements/capabilities |
PDE now handles dependencies described by the
Require-Capability and Provide-Capability manifest headers.
These dependencies are taken additionally into account when computing the required bundles for a selected set of bundles
from the target platform.
The most noticeable place where this feature is in the Eclipse launch configuration page
i.e. Eclipse launch configuration -> Plug-ins -> Add Required Plug-ins
For example, a usual effect is that the plug-in Further the computation of required plug-ins is performed recursively now until added plug-ins do not introduce more transitive requirements. |
Launch configuration prototypes for Eclipse Launch Configurations |
An Eclipse Launch Configuration can now be based on a prototype.
A prototype seeds attributes in its associated Eclipse Launch Configurations with the settings specified in the Prototype tab. Once an Eclipse Launch Configuration has been created, you can override any initial settings from the prototype. You can also reset the settings of an Eclipse Launch Configuration with the ones from its prototype. An Eclipse Launch Configuration maintains a link to its prototype, but is a complete stand-alone launch configuration than can be launched, exported, shared, etc.
|
Platform Developers | |
CodeMining support with SourceViewer |
A code mining represents a content (ex: label, icons) that should be shown along with source text, like the number of references, a way to run tests (with run/debug icons), etc. The main goal of code mining is to help developer to understand more the written/writing code A code mining is represented byorg.eclipse.jface.text.codemining.ICodeMining which are provided by org.eclipse.jface.text.codemining.ICodeMiningProvider
The org.eclipse.jface.text.source.ISourceViewerExtension5 provides the capability to register org.eclipse.jface.text.codemining.ICodeMiningProvider and update code minings.
The example CodeMiningDemo draws classes references / implementations code minings:
|
CodeMining provider Extension point |
The org.eclipse.ui.workbench.texteditor.codeMiningProviders extension point gives the capability to register code mining providers org.eclipse.jface.text.codemining.ICodeMiningProvider in text editor using ISourceViewerExtension5 .
Associating providers via this extension doesn't automatically enable code-mining, so that clients are also supposed to use a reconciler or whatever event mechanism to invoke ISourceViewerExtension5.updateCodeMinings() .
For instance you can consume the org.eclipse.jface.text.codemining.CodeMiningReconciler to update the registered CodeMining providers.
The GenericEditor Example display number of referenced projects:
This sample consumes the code mining provider ProjectReferencesCodeMiningProvider
which is registered with the <extension point="org.eclipse.ui.workbench.texteditor.codeMiningProviders"> <codeMiningProvider class="org.eclipse.ui.genericeditor.examples.dotproject.codemining.ProjectReferencesCodeMiningProvider" id="org.eclipse.ui.genericeditor.examples.dotproject.codemining.references" label="Project references"> <enabledWhen> <with variable="editorInput"> <adapt type="org.eclipse.core.resources.IFile"> <test property="org.eclipse.core.resources.contentTypeId" value="org.eclipse.ui.genericeditor.examples.dotproject" /> </adapt> </with> </enabledWhen> </codeMiningProvider> </extension> This code mining provider is updated with the <extension point="org.eclipse.ui.genericeditor.reconcilers"> <reconciler class="org.eclipse.jface.text.codemining.CodeMiningReconciler" contentType="org.eclipse.ui.genericeditor.examples.dotproject"> </reconciler> </extension> |
Action for Inlined Annotations |
Inlined annotation can define an action to execute when you click on the annotation with Consumer<MouseEvent> getAction(MouseEvent e) .
The example InlinedAnnotationDemo defines
an action to open the public ColorAnnotation extends LineContentAnnotation { ... @Override public Consumer<MouseEvent> getAction(MouseEvent e) { return ev -> { // Open the Color dialog when color annotation is clicked }; } }
|
Launch configuration prototypes |
A launch configuration can now be based on a prototype.
A prototype seeds attributes in its associated launch configurations with the settings specified in the Prototype tab. Once a launch configuration has been created, you can override any initial settings from the prototype. You can also reset the settings of a launch configuration with the ones from its prototype. A launch configuration maintains a link to its prototype, but is a complete stand-alone launch configuration than can be launched, exported, shared, etc. Prototypes are already enabled for JDT and PDE launch configurations. Others projects have to enable prototypes in org.eclipse.debug.core.launchConfigurationTypes extension point:
<extension point="org.eclipse.debug.core.launchConfigurationTypes"> <launchConfigurationType allowPrototypes="true" delegate="org.eclipse.jdt.launching.sourcelookup.advanced.AdvancedJavaLaunchDelegate" delegateDescription="%localJavaApplicationDelegate.description" delegateName="%eclipseJDTLauncher.name" id="org.eclipse.jdt.launching.localJavaApplication" migrationDelegate="org.eclipse.jdt.internal.launching.JavaMigrationDelegate" modes="run, debug" name="%localJavaApplication" sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector" sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer"> </launchConfigurationType> </extension>and also implement org.eclipse.debug.ui.AbstractLaunchConfigurationTab.initializeAttributes() for their specifics tabs.
|
Group widget text color stylable on Windows |
The Group widget text can now have a different color than the system default. Client can use Group#setForeground(Color)
to change the text color. Screen-shot for reference:
|
New API getOffsetAtLocation(Point) added to StyledText |
The new method StyledText#getOffsetAtPoint(Point) is a replacement for
StyledText#getOffsetAtLocation(Point) . It behaves similar, except that it does
not throw an IllegalArgumentException when no character is at the given location,
but returns -1 instead.
Using the new method will result in better performance when used in tight loops. Especially the Show Whitespace editor feature benefits from using the new API.
The method |
New event SWT.OpenUrl added |
A new event type SWT.OpenUrl has been added to SWT to notify clients that an URL should be opened.
Listeners for OpenUrl event should be added to a Display. The event's text field contains the URL to be opened.
URLs can be passed to Eclipse in the same way in which file paths are passed from the command line (i.e, as arguments to the default action
|
Webkit2 is now the default Browser renderer on Linux/GTK |
Preliminary support for Webkit2 on Linux/GTK was added in Eclipse Luna.
Webkit2 support is now complete and has replaced Webkit1 as the default renderer for the SWT Browser widget on Linux/GTK.
Webkit1 was known to crash at times. Webkit2 is stable and runs in a separate process, thus providing enhanced performance and is more secure. Webkit2 was also necessary because Webkit1 is no longer being provided on newer Linux distributions (e.g Fedora 27) To fallback to using Webkit1 (if needed), you can set the environment variable using: To inspect which version of Webkit you're running Eclipse under, set variable: See Webkit2 port bug for more details. |
JDT Developers | |
Support for Regex Module Declaration Search |
The existing method SearchPattern#createPattern(String , int , int , int ) is enhanced for
supporting regular expression search for module declarations. Please note that the flag
SearchPattern#R_REGEXP_MATCH used for regular expression search is applicable exclusively for
module declarations. No other flag (for eg.SearchPattern#R_CASE_SENSITIVE ) should be used in
disjunction with this match rule.
|
The above features are just the ones that are new since the previous milestone build. Summaries for earlier Photon milestone builds: