*** Jikes 1.22 was released 3 October 2004

This release supports compilation using the rt.jar shipped with
the released version of Java 5.0, but otherwise has no more
support for new language features than 1.21 did.

These specification problems are fixed:

    3986  jikes compiles faulty source without error or warning
    4042  constructor of strictfp class not strictfp
    4046  no warning when overriding a deprecated method

These crashes on valid or invalid source are fixed:

    3934  Assertion failed: ! array tuple.h line 429
    3972  "Assertion failed" on incorrect String operations
    3974  Assertion failed: type == control.String()
    3989  Assertion `! array' failed with String.class literal

These problems with diagnostics are fixed:

    3424  Confusing error message for type not found error
    3947  static method local shouldn't shadow instance field

These other problems are fixed:

     495  classpath problems introduced by 1.14
    4018  errno undefined (freebsd-4.8

*** Jikes 1.21 was released 16 May 2004

A regression in 1.20 that caused us to complain about supposedly
invalid .class files has been rectified. Some minor error message
improvements have been made.

*** Jikes 1.20 was released 18 April 2004

Many new diagnostics have been added. These include detection of
overflow in integer constant expressions, serialization-related
checks made by Java 1.5's javac, detection of locals shadowing
fields (often caused by an unfinished refactoring that promotes a
local to a field) and fields in subclasses that hide fields in
superclasses. New command-line options generalize the old -nowarn/+Z
to also allow all warnings to be considered errors (with +Z2). The
default on vs. off state of several warnings added in 1.19 have been
changed, by popular demand.

Jikes is more robust in the face of a .java file on the command line
that requires another .java file that has a compilation error.
However, this area can always be improved, so we appreciate concise
test cases where a single error is causing a chain of error messages.

Jikes makes a better attempt to detect and warn the user of system
errors, such as file not found or directory not writeable.

The set of legal characters in identifiers has grown according to
Unicode 4.0.  Now surrogate character pairs are parsed correctly,
according to the improvements in the JDK 1.5 java.lang.Character, so
that something like \ud801\udc00 is now an identifier.

Jikes now correctly detects an attempt to use a non-static member
class from a static one, without proper qualification.  Since javac
does not yet correctly enforce this, it is likely that existing code
has the following bug:
class Outer {
  class NonStatic {}
  static class Static {
    NonStatic a; // illegal, jikes now correctly gives an error
    Outer.NonStatic b; // legal, the proper workaround
  }
}

As always, several bugs from the Jikes bug database have been closed.

Build support has been slightly improved.  Jikes now builds correctly
with parallel make invocations, is better at detecting a working iconv
that meets jikes' needs, and will use RTTI in debugging mode to help
diagnose cast errors.  Upstream automake and autoconf improvements
allow jikes to compile and install on more platforms.

The `-target 1.5' option produces class files compatible with Sun's
JDK 1.5 virtual machine (the biggest changes are that class literals
take much less space, and String concatenation is more efficient).
Also, the EnclosingMethod attribute is now used to improve reflection.
Fixed bug where compiling with classfiles produced by JDK 1.5 caused
an assertion error when read by jikes.

Some beta support for JDK 1.5 features is being added.  To try it out,
you must build jikes yourself, and use the --enable-source15 configure
option.  Once compiled, the following items are supported by using the
`-source 1.5' command line argument (but possibly with bugs):
- Hexadecimal floating point literals, documented in
java.lang.Float.valueOf(String) and similar to the C99 language.  For
example, 0x1.8p+0d is now the same as 1.5d.
- The enhanced loop of JSR 201 is (mostly) supported.  The only
non-specified behavior is a compiler hack to allow using a non-Object
variable when looping over an iterator, since generic iterators are
not yet supported.  For example, this code:
  for (int i : new int[] {1});
  for (Object o : Collections.singleton(""));
is short for:
  int[] ia = new int[] {1};
  for (int i1 = 0; i1 < ia.length; i1++) {
    int i = ia[i1];
  }
  for (Iterator it = Collections.singleton("").iterator();
       i.hasNext(); ) {
    Object o = i.next();
  }
- Generics (type parameters) parse correctly, but are not otherwise
supported.
- Annotations parse correctly, but are not otherwise supported.
- Variadic methods (varargs) parse correctly, but are treated as
though the final parameter used '[]' instead of '...'.
- Enumerations parse correctly, but are not otherwise supported.
- Static imports parse correctly, but are not otherwise supported.
- Autoboxing and autounboxing are not supported.

*** Jikes 1.19 was released 1 February 2004.

The default -source and -target options are now 1.4 (that is, the
assert statement now compiles by default); for the old behavior you
must specify -source 1.3 or -target 1.3 at the command line.

Command line options have been improved.
* Some pedantic warnings are controlled by name, so that you can
select which warnings you get (for example, not everyone wants to know
that 1L is preferred over 1l when writing a long literal).
* More switches have long names.
* Default state of switches now printed with --help.
* New switch -Xswitchcheck: Warn about fallthrough in switch
statements (compatible with javac).
* New switch +Pnaming-convention: Warn about naming choices that
violate Java's naming conventions. This switch is currently ON by
default, +Pno-naming-convention will disable it for sites that use
a different naming convention.
* New switch --noassert: Omits assertions from .class files (not
recommended for normal development, but provided to allow you to do
-source 1.4 -target 1.3).
* Now supports -target 1.4.2 (compatible with javac, no changes from
-target 1.4 in emitted code).

Warnings are given for some common violations of Joshua Bloch's book
"Effective Java."  Error text has been improved for method calls, to
list the parameter types the compiler is trying to match.  Error text
on duplicate declarations tries harder to list the original
declaration.

The identifier `enum' will become a keyword once -source 1.5 is
implemented (JDK 1.5: addition of generics (JSR 14); attributes (JSR
175); autoboxing, enhanced for loop, enums, static import, and varargs
(JSR 201); and enhanced .class files (JSR 202)).  Therefore, the
compiler now warns where it is used as an identifier.

The check for method ambiguity no longer looks at the type that
declared each method.  Code that once caused an ambiguous method error
is now legal, per Sun bug 4761586:
class A {
  void m(byte b) {}
}
class B extends A {
  void m(int i) {}
  void foo(byte b) {
    m(b); // now calls inherited A.m(byte), rather than ambiguous
  }
}

Blank finals used inside a local class must be definitely assigned
before the class declaration, rather than simply before all calls to a
constructor of the local class.  For example, this code now causes an
error:
class C {
  void m() {
    final int i;
    class Local { int j = i; } // i has not been assigned before here
    i = 1;
    new Local(); // even though it has been before creating a Local
  }
}

The scope of a local class declaration statement in a switch statement
is corrected to be only the nearest case label (unlike local variable
declarations which remain in scope for the entire switch
statement). This has the following effects:
class D {
  void m(int i) {
    switch (i) {
    case 0:
      class One {}
      class Two {}
      int j;
      int k;
      break;
    case 1:
      // new One(); // now illegal, declaration no longer in scope
      class Two {} // now legal, no conflict with prior declaration
      j = 1; // remains legal as before
      // int k; // remains illegal as before
    }
  }
}

Constant instance variables are now initialized sooner, so that you
cannot view their default 0 value even with reflection.

The statement 'throw null;' is now treated as an unchecked exception,
since it always results in a NullPointerException being thrown. This
also means that throwing null does not make a checked exception catch
clause reachable.

Improved the parser. A few more syntactic errors have been deferred to
semantic errors, in order to give a more helpful message.  The parser
is slightly faster [for those that know parser theory, it is now
LALR(1) instead of LALR(2)].

The compiler now works around a bug in VMs when storing an array into
a multi-dimensional array expression that happened to be null.

Extraneous error messages about non zip or jar content in extdirs has
been removed.

As always, minor bug fixes for several bugs in the database.

*** Jikes 1.18 was released 21 November 2002.

Compilation that encounters syntax errors is more robust.
An assertion failure involving placeholder_type was solved.
Other minor bugs have been fixed.

*** Jikes 1.17 was released 27 September 2002.

The regression with empty if-clauses was fixed.
Inheritance issues and name shadowing were improved.
Package handling was improved somewhat.
Many other bugs were fixed.

NEWS was not properly maintained in prior versions.