JEP 179: Document JDK API Support and Stability

AuthorJoseph D. Darcy
OwnerJoe Darcy
Created2013/03/13 20:00
Updated2014/07/10 20:16
TypeFeature
StatusCompleted
ScopeJDK
Discussioncore dash libs dash dev at openjdk dot java dot net
EffortXS
DurationS
Priority4
Reviewed byAlan Bateman
Endorsed byMark Reinhold
Release8
Issue8046169
DependsJEP 162: Prepare for Modularization
Relates to8008267: Add @Supported annotation to com.sun.source types
8001614: Include annotation type to documented supported-ness of JDK-specific types
8008662: Add @jdk.Exported to JDK-specific/exported APIs

Summary

There is a long-standing shortcoming in the JDK in terms of clearly specifying the support and stability usage contract for com.sun.* types and other types shipped with the JDK that are outside of the Java SE specification. These contracts and potential evolution policies should be clearly captured both in the source code of the types and in the resulting class files. This information can be modeled with JDK-specific annotation types.

Goals

The primary goals of this proposal are to capture the results of the pre-modularization investigations around the status of these APIs and to make that information clearer to the maintainers of the JDK and developers using the JDK.

Marking an API as usable by certain parties, but not generally usable, could also be helpful.

Non-Goals

The expected implementation mechanism to store the API status information is one or more annotation types with supporting types for modeling, such as enums. These types are intended for use in the JDK. If they are useful outside of the JDK that is a happy outcome, but, for instance, designing a very general-purpose classification scheme with very fine gradations of stability levels is out of scope for this effort.

Motivation

In addition to implementing Java SE APIs, the JDK code base contains sources for, and JDK distributions ship with, other APIs outside of the Java SE specification and in different namespaces. Some of those JDK APIs enjoy a similar general evolution policy as Java SE APIs; the APIs are usable for general development, supported by the JDK provider, stable, and evolve in a largely compatible fashion. Other APIs included in the JDK are intended only for use in the JDK implementation itself and should not be relied on by third parties. The com.sun.* namespace used by the JDK includes a mixture of these "supported" and "not-supported" APIs. This JEP proposes to record information about supported-ness and related properties of interest in the sources of the types and packages in question. Recording this information will make the status of the API clearer and more explicit, including in generated javadoc, and also allow tooling to programmatically check for inappropriate usage. The recording of this information should be addressed by a small incremental effort over and above the modularity preparation already being done for JDK 8 in JEP 162.

Description

The annotations and supporting types used to document the status the APIs of interest will reside in the jdk.* namespace. In other words, these types will be part of the JDK and not part of Java SE. Besides new types added in jdk.* itself, the annotations are expected to mostly be used on types in the legacy com.sun.* namespace. Some exploration and experimentation is expected before the final set of API distinctions is determined. The initial jdk.Supported annotation type, which was already pushed into JDK 8 to allow trial usage, allows a boolean supported/not-supported classification. Other possible classifications of interest include JRE vs JDK, supported outside of the JDK only for certain users/groups, and stability/evolution policy gradations.

In following the don't-repeat-yourself principle, ultimately the JDK build should be modified to construct the ct.sym proto-module system information from annotations on sources rather than obscurely relying on the docs makefile, but such a build refactoring is not a strictly necessary part of this effort.

Risks and Assumptions

If the annotations of this feature are initially designed to only capture a yes/no value of some sort as a boolean and in the future having more classifications is deemed necessary, it may be awkward to evolve the initial type(s) to model the new scheme. Therefore, care should be taken in JDK 8 to determine a durable set of distinctions.

Dependences

This feature builds on the investigations conducted for JEP 162, Prepare for Modularization.

Impact