JSR 308 Prototype Implementation README

Version 0.3.99 (20 Nov 2007)

Contents:

• Introduction
• Features of the JSR 308 prototype implementation
  • The -typeprocessor javac command-line option
  • Writing annotations on types in a backward-compatible manner
  • The -annotations javap command-line option
  • Differences from the JSR 308 proposal
• Building the JSR 308 “langtools”
• Differences from the OpenJDK distribution
  • Determining a diff against the OpenJDK distribution
• Contributing
  • How to report bugs
  • Credits and changelog

Introduction

The JSR 308 “prototype implementation” (also called the “reference implementation”) is a version of the OpenJDK Java 7 “langtools” that have been updated to support JSR 308. JSR 308 is a backward-compatible extension of the Java language that permits annotations to appear on types.

You may use the JSR 308 implementation as a replacement for the OpenJDK or any other Java implementation. In particular, you may use the JSR 308 javac compiler as a drop-in replacement for the OpenJDK javac compiler or any other compiler for the Java 7 language.

The “Building the compiler” section below contains instructions for building, running, and testing the compiler.

IDEs such as Eclipse have not yet been updated to support JSR 308. To use the JSR 308 compiler with Eclipse, write an Ant buildfile that compiles your project (using the JSR 308 compiler), then build by running Ant. Problem markers will show up in the Eclipse IDE as normal. (You will lose a few Eclipse features, such as error checking as you type, until Eclipse's internal compiler is updated for JSR 308.)

Features of the JSR 308 prototype implementation

The JSR 308 prototype implementation is a Java compiler that supports the JSR 308 specification (PDF, HTML), which permits annotations to appear on any occurrence of a type.

The -typeprocessor javac command-line option

The JSR 308 compiler adds the -typeprocessor command-line option for running annotation processors. The -typeprocessor option is semantically similar to the standard -processor option: either option is followed by a list of the (fully-qualified) class names of the annotation processors to run. An example (using the NonNull checker) is:

  javac -typeprocessor checkers.nonnull.NonnullChecker MyFile.java

Annotation processors specified using the -typeprocessor option are invoked after the compiler's attribution phase (also known as type resolution), giving the processor access to completed symbols. By contrast, processors specified using the -processor option are invoked before the compiler's attribution phase.

Note: In the prototype implementation, the -typeprocessor and -processor options are mutually exclusive and should not be used simultaneously.

Writing annotations on types in a backward-compatible manner

The prototype implementation of the JSR 308 compiler allows annotations to be written in "/* */" (C-style) comments, without whitespace between the comment delimiters and the annotation name, e.g., /*@NonNull*/. This mechanism allows developers to use JSR 308 annotations while maintaining the ability to compile their code with an unmodified Java compiler, including compilers for earlier versions of the Java language (such as Java 5 or Java 6). This temporary mechanism will not be part of the official Java language when JSR 308 is incorporated into it.

The -annotations javap command-line option

The JSR 308 javap tool adds the -annotations command-line option for displaying the properties of both JSR 175 and JSR 308 annotations. The OpenJDK javap tool normally displays annotations as raw hexadecimal strings; the modified tools parses the annotations and displays their names, arguments, and other properties (including the internal fields of JSR 308 annotations as specified in Section 4 of the JSR 308 proposal.

Since annotation attributes are typically only displayed in conjunction with the -verbose command-line option, the -annotations option does nothing without the -verboseoption.

Differences from the JSR 308 proposal

The JSR 308 prototype compiler implementation differs from the design specified in the JSR 308 proposal in the following ways, which will be corrected in the future:

• support for generic type arguments in a generic method invocation is limited
• support for annotations on class literals is limited to the parser (i.e., annotations are not added to the AST or compiled into class files)

Building the JSR 308 “langtools”

It can be difficult to build the entire OpenJDK. For example, to build on Linux requires a specific operating system version, and attempts to build on any other version are likely to fail. Therefore, we suggest the following approach:

1. Download a JDK 7 (not JRE 7) binary snapshot, and follow the installation instructions. Be sure to update your PATH with the location of the newly-installed java executable, and your JAVA_HOME environment variable to point to the top-level directory of the JDK 7 installation. (The shell uses the PATH variable to locate java, while Ant uses JAVA_HOME.)
2. Download the JSR 308 prototype implementation, and unpack it (somewhere different than the JDK 7 installation you downloaded in the preceding step). By default, the archive will create a langtools directory when extracted.
3. Compile only the JSR 308 compiler by running ant build-javac in directory langtools/make.
4. (Optional) Compile only the JSR 308 javap tool by running ant build-javap in the directory langtools/make.
5. Add the langtools/dist/bin directory to the front of your PATH environment variable. Now, the javac command invokes the JSR 308 Java compiler and the javap command invokes the JSR 308 javap, but the Java 7 OpenJDK (that you installed in the first step) is used for everything else.
6. Confirm that the output of javac -version contains the string jsr308, such as javac 1.7.0-jsr308-0.3.
   If the output is does not contain jsr308 (e.g., javac 1.7.0-ea), but you are using the correct javac binary (in langtools/dist/bin), then it is possible that tools.jar is on your classpath. You should either remove tools.jar from your classpath, or else put langtools/dist/lib/javac.jar and/or langtools/dist/lib/javap.jar on your classpath before tools.jar.

In the future, we will distribute binary versions of the JSR 308 prototype implementation, which will simplify the installation process.

Differences from the OpenJDK distribution

The JSR 308 distribution includes only the langtools portion of the OpenJDK distribution. The JSR 308 prototype implementation makes no modifications in other parts of the OpenJDK distribution, and the remaining parts of the distribution are not necessary to build and use the JSR 308 tools.

This JSR 308 distribution differs from the langtools portion of Sun's OpenJDK distribution in the following ways:

• The compiler source code (which is located in langtools/src/share/classes) supports the JSR 308; it permits annotations to appear on any occurrence of a type.
• The -typeprocessor command-line option, which runs an annotation processor after types have been resolved, has been added to the compiler.
• The compiler parses both JSR 175 and JSR 308 annotations written in specifically-formatted comments for backward compatibility.
• Five javac test cases are skipped by the test runner due to failures caused by JSR 308 modifications. These test cases will be corrected and re-enabled in a future release.
  Note that not all tests remaining pass — but all failing tests also fail for the OpenJDK compiler. The JSR 308 changes do not introduce any test failures.
• The javap tool has been modified to display the properties of both JSR 175 and JSR 308 annotations via the -annotations command-line option.
• This documentation file has been included.

Additionally, your javac will not properly pass -J<flag> flags to the runtime system. This is a problem with the OpenJDK system, not with the JSR 308 changes. If you wish to adjust the arguments to the runtime system (i.e., java), then you will need to edit langtools/dist/bin/javac.

Determining a diff against the OpenJDK distribution

The JSR 308 distribution is a modification of the langtools portion of Sun's OpenJDK javac distribution. The version of OpenJDK on which the JSR 308 distribution is based is:

r251 (Thu, 13 Sep 2007)

The following commands determine the differences between the JSR 308 compiler and the OpenJDK compiler. The shell variable $VENDOR refers to the location of the unmodified source code and $JSR308 refers to the location of the extracted JSR 308 compiler distribution.

1. If you do not have a checkout of the OpenJDK compiler, obtain one (use an empty password for username guest):

   
     export VENDOR=vendor-langtools
     svn co https://openjdk.dev.java.net/svn/openjdk/jdk/trunk/langtools $VENDOR -r251 --username guest
     

   If you already have a checkout of the OpenJDK compiler, ensure that it is at the same revision as the modifications, using the following command in the $VENDOR directory:

   
     svn update -r251
     

2. Use one of these diff commands to generate the differences. The second shows the contents of new files, whereas the first only reports that the new file exists.

   
     diff -ur -x .svn -x dist -x build $VENDOR/src $JSR308/j2se/src
     diff -urN -x .svn -x dist -x build $VENDOR/src $JSR308/j2se/src
     

Contributing

We welcome bug fixes, new features, type-checking plug-ins, and other improvements. All contributions to javac (annotation-related or not) should follow the guidelines for contributing to javac. Any code contributed to javac or to the JSR 308 prototype implementation is contributed to Sun under Sun's Contributor Agreement (SCA).

How to report bugs

If you have any problems with the compiler, please let us know; we welcome bug reports and suggestions. We will fix all reported bugs in the JSR 308 prototype implementation. Examples of bugs include:

• Any inconsistency between the JSR 308 compiler and the JSR 308 design (PDF, HTML).
• Any annotation-related problem.
• Any problem that occurs with the JSR 308 compiler but does not occur with the OpenJDK Java 7 compiler on which the JSR 308 compiler is built.

The JSR 308 compiler is built on Sun's OpenJDK compiler. If you find a bug in the JSR 308 compiler, it might be due to a bug in the OpenJDK compiler (in which case it should be reported to Sun), or it might be due to the JSR 308 modifications (in which case it should be reported to the JSR 308 compiler implementers). In some cases (such as a problem with processing annotations on types), the responsibility is clearly with the JSR 308 modifications. Otherwise, please determine who is responsible for the bug using this procedure:

1. Obtain a copy of version 251 of the OpenJDK compiler, using the commands in the diff section of this document.
2. Try your test case using the OpenJDK compiler. If the problem is present, then search the bug database (use the “Java” category). If the problem is not in the bug database, then report your bug to Sun, using category “Java” and subcategory “compiler”.

If the problem is present in the JSR 308 compiler, but not in the OpenJDK compiler, then please report it to us. Send your bug report to jsr308-bugs@lists.csail.mit.edu. This is not a mailing list for general support or questions.

Please ensure that your bug report is clear and that it is complete. Otherwise, we may be unable to understand it or to reproduce it, either of which would prevent us from fixing the bug. Sun has a description of how to write a helpful bug report. Here are some crucial points:

• Indicate exactly what you did. Show the exact commands (don't merely describe them in words). Don't skip any steps.
• Include all files that are necessary to reproduce the problem. This includes every file that is used by any of the commands you reported, and possibly other files as well.
• Indicate exactly what the result was (don't merely describe it in words). Also indicate what you expected the result to be — remember, a bug is a difference between desired and actual outcomes.
• Indicate which version of the JSR 308 compiler you are using. You can determine that by running javac -version.

Credits and changelog

The JSR 308 compiler was implemented by Matthew M. Papi as a modification of the Sun OpenJDK compiler. See above for how to report bugs.

Differences from previous versions of the JSR 308 implementation may be found in the changelog.

JSR 308 webpage