Version 0.9.2, 2 Jun 2009

Functionality
  Added pre-liminary support for lazy initialization in nullness
    see LazyNonNull

Bug fixes
  Corrected method declarations in JDK skeleton files
    - bug resulted in a runtime error

Documentations
  Updated qualifier javadoc documentations
  Corrected a reference on passing qualifiers to javac

----------------------------------------------------------------------
Version 0.9.1, 19 May 2009

Bug fixes
  Eliminated unexpected compiler errors when using checkers
  Fixed bug related to reading annotations in skeleton files

API Changes
  Renamed SourceChecker.process() to .typeProcess()

Manual
  Updated troubleshooting info
    info for annotations in skeleton files

----------------------------------------------------------------------
Version 0.9b, 22 Apr 2009

No visible changes

----------------------------------------------------------------------
Version 0.9, 16 Apr 2009

Framework
  More space and performance optimizations
  Handle raw type with multiple type var level
    e.g. class Pair<X, Y extends X> { ... }

Manual
  Improve installation instructions
  Update references to command line arguments

----------------------------------------------------------------------
Version 0.8.9, 28 Mar 2009

Framework
  Introduce Space (and minor performance) optimizations
  Type-check constructor invocation receiver type
  Fixed bug related to try-catch flow sensitivity analysis
  Fixed bugs when type-checking annotations and enums
    - bug results in null-pointer exception

----------------------------------------------------------------------
Version 0.8.8, 13 Mar 2009

Nullness Checker
  Support for custom nullness assertion via @AssertNonNull
  Support for meta-annotation AssertNonNull
  Support for Collection.toArray() method
    Infer the nullness of the returned type
  Corrected some JDK Collection API annotations

Framework
  Fixed bugs related to assignments expressions in Flow
  Fixed bugs related to enum and annotation type hierarchy
  Fixed bugs related to default annotations on wildcard bounds

----------------------------------------------------------------------
Version 0.8.7, 27 Feb 2009

Framework
  Support annotations on type parameters
  Fixed bugs related to polymorphic types/annotations
  Fixed bugs related to stub fixes

Manual
  Specify annotation defaults settings for IGJ
  Update Known Problems section
----------------------------------------------------------------------
Version 0.8.6, 3 Feb 2009

Framework
  Fixed bugs related to flow sensitivity analysis related to
    . for loop and do while loops
    . multiple iterations of a loop
    . complement of logical conditions
  Declarative syntax for string literal type introduction rules
  Support for specifying stub file directories

----------------------------------------------------------------------
Version 0.8.5, 17 Jan 2009

Framework
  Fixed bugs related to flow sensitivity analysis
  Fixed bugs related to annotations on type parameters

----------------------------------------------------------------------
Version 0.8.4, 17 Dec 2008

Distribution
  Included checkers-quals.jar which contains the qualifiers only

Framework
  Fixed bugs related to inner classes
  Fixed a bug related to resolving polymorphic qualifiers
    within static methods

Manual
  Added 'Distributing your annotated project'

----------------------------------------------------------------------
Version 0.8.3, 7 Dec 2008

Framework
  Fixed bugs related to inner classes
  Changed cast semantics
    Unqualified casts don't change cast away (or in) any qualifiers
  Refactored AnnotationBuilder to ease building annotations
  Added support for Object += String new behavior
  Added a type validation check for method return types

Nullness
  Added inference of field initialization
    Suppress false warnings due to method invocations within constructors

IGJ
  Added proper support for AssignsFields and inner classes interactions

Manual
  Updated 'Known Problems' section

----------------------------------------------------------------------
Version 0.8.2, 14 Nov 2008

Framework
  Included a binary distribution in the releases
  Added support for annotations on type parameters
  Fixed bugs related to casts

Nullness
  Improved error messages readability
  Added partial support for Map.get() detection

Manual
  Improved installation instructions

----------------------------------------------------------------------
Version 0.8.1, 1 Nov 2008

Framework
  Added support for array initializers
  Fixed many bugs related to generics and generic type inference

Documentations
  Added 'Getting Started' guide

----------------------------------------------------------------------
Version 0.8, 27 Sep 2008

Framework
  Added support for newly specified array syntax
  Refactored code for annotating supertypes
  Fixed AnnotationBuilder AnnotationMirror string representation
  Fixed AnnotatedTypeMirror hashCode

Manual
  Reorganized 'Annotating Libraries' section

----------------------------------------------------------------------
Version 0.7.9, 19 Sep 2008

Framework
  Added support for stub files/classes
  Fixed bugs related to anonymous classes
  Fixed bugs related to qualifier polymorphism

Manual
  Updated 'Annotating Libraries' section to describe stub files

Tests
  Added support for Windows
  Fixed a bug causing IGJ tests to fail on Windows

----------------------------------------------------------------------
Version 0.7.8, 12 Sep 2008

Framework
  Improved support for anonymous classes
  Included refactorings to ease extensibility
  Fixed some minor bugs

Nullness
  Fix some errors in annotated JDK

----------------------------------------------------------------------
Version 0.7.7, 29 Aug 2008

Framework
  Fixed bugs related to polymorphic qualifiers
  Fixed bugs related to elements array convention
  Add implicit type arguments to raw types

Interning
  Suppress cast warnings for interned classes

Manual
  Removed discussion of non-standard array syntax alternatives

----------------------------------------------------------------------
Version 0.7.6, 12 Aug 2008

Framework
  Changed default array syntax to ARRAYS-PRE, per the JSR 308 specification
  Added an optional check for qualifier unsafe casts
  Added support for running multiple checkers at once
  Fixed bugs related array syntax
  Fixed bugs related to accessing outer classes with-in inner classes

Manual
  Added a new subsection about Checker Auto-Discovery
    2.2.1 Checker Auto-discovery

----------------------------------------------------------------------
Version 0.7.5, 2 Aug 2008

Framework
  Added support for ARRAYS-PRE and ELTS-PRE array syntax
  Added a check for unsafe casts
  Some improvements to the AnnotationBuilder API

Nullness Checker
  Added a check for synchronized objects
  Added a check for (un)boxing conversions

Javari Checker
  Fixed some JDK annotated classes

----------------------------------------------------------------------
Version 0.7.4, 11 July 2008

Framework
  Added support for annotations found in classfiles
  Added support for the ARRAY-IN array syntax
  Added AnnotationBuilder, to create AnotationMirrors with values
  Improved the readability of recursive types string representation

Nullness Checker
  Added a check for thrown Throwable nullability

IGJ Checker
  Treat enums as mutable by default, like regular classes

Manual
  Added a new subsection about array syntax proposals:
    2.1.2 Annotating Arrays

----------------------------------------------------------------------
Version 0.7.3,  4 July 2008

Javari Checker
  Converted JDK files into stubs

Nullness Checker
  Fixed java.lang.Number declaration in the annotated jdk

Framework
  Fixed a bug causing crashes related to primitive type boxing
  Renamed DAGQualifierHierarchy to GraphQualifierHierarchy

----------------------------------------------------------------------
Version 0.7.2, 26 June 2008

IGJ Checker
  Supports flow-sensitive type refinement

Framework
  Renamed Default annotation to DefaultQualifier
  Added DefaultQualifiers annotation
  Fixed bugs related to flow-sensitive type refinement
  Fixed an error in the build script in Windows

Manual
  Added a new section
    9.2  javac implementation survival guide
  Added hyperlinks to Javadocs of the referenced classes

----------------------------------------------------------------------
Version 0.7.1, 20 June 2008

Nullness Checker
  Made NNEL the default qualifier scheme

Basic Checker
  Moved to its own checkers.basic package

Framework
  Enhanced type checking within qualifier-polymorphic method bodies
  Fixed a bug causing StackOverflowError when type-checking wildcards
  Fixed a bug causing a NullPointerException when type-checking
    compound assignments, in the form of +=

Class Skeleton Generator
  Distributed in compiled form (no more special installation instructions)
  Added required asmx.jar library to lib/

Manual
  Added new sections
    2.2.1 Ant tasks
    2.2.2 Eclipse plugin
    2.6   The effective qualifier on a type
  Rewrote section 8 on annotating libraries
    Added reference to the new Eclipse plug-in
    Deleted installation instructions

Javari Checker
  Fixed bugs causing a NullPointerException when type-checking
    primitive arrays

IGJ Checker
  Fixed bugs related to uses of raw types

API Changes
  Moved AnnotationFactory functionality to AnnotationUtils
  Removed .root and .inConflict from DAGQualifierHierarchy

----------------------------------------------------------------------
Version 0.7, 14 June 2008

Installation
  New, very simple installation instructions for Linux.  For other
    operating systems, you should continue to use the old instructions.

Nullness Checker
  Renamed from "NonNull Checker" to "Nullness Checker".
    Renamed package from checkers.nonnull to checkers.nullness.
    The annotation names remain the same.
  Added PolyNull, a polymorphic type qualifier for nullness.

Interning Checker
  Renamed from "Interned Checker" to "Interning Checker".
    Renamed package from checkers.interned to checkers.interning.
    The annotation names remain the same.
  Added PolyInterned, a polymorphic type qualifier for Interning.
  Added support for @Default annotation.

Framework
  Qualifiers
    @PolymorphicQualifier was not previously documented in the manual.
    Moved meta-qualifiers from checkers.metaquals package to checkers.quals.
    Removed @VariableQualifier and @RootQualifier meta-qualifiers.
  Added BasicAnnotatedTypeFactory, a factory that handles implicitFor,
    defaults, flow-sensitive type inference.
  Deprecated GraphQualifierHierarchy; DAGQualifierHierarchy replaces it.
  Renamed methods in QualifierHierarchy.

Manual
  Rewrote several manual sections, most notably:
    2.1.1  Writing annotations in comments for backward compatibility
      (note new -Xspacesincomments argument to javac)
    2.3  Checking partially-annotated programs: handling unannotated code
    2.6  Default qualifier for unannotated types
    2.7  Implicitly refined types (flow-sensitive type qualifier inference)
    8  Annotating libraries
    9  How to create a new checker plugin
  Javadoc for the Checker Framework is included in its distribution and is
    available online at http://groups.csail.mit.edu/pag/jsr308/current/doc/ .

----------------------------------------------------------------------
Version 0.6.4, 9 June 2008

All Framework
  Updated the distributed JDK and examples to the new location of qualifiers

Javari Checker
  Improved documentation on polymorphism resolution
  Removed redundant code now added to the framework from JavariVisitor,
    JavariChecker and JavariAnnotatedTypeFactory
  Refactored method polymorphism into JavariAnnotatedTypeFactory
  Fixed bug on obtaining type from NewClassTree, annotations at constructor
    invocation are not ignored now
  Refactored polymorphism resolution, now all annotations on parameters and
    receivers are replaced, not only on the return type
  Refactored and renamed internal annotator classes in
    JavariAnnotatedTypeFactory
  Added more constructor tests
  Moved Javari annotations to checkers.javari.quals package

----------------------------------------------------------------------
Version 0.6.3, 6 June 2008

Checker Framework
  Improved documentation and manual
  Treat qualifiers on extends clauses of type variables and wildcard types as
    if present on type variable itself
  Renamed AnnotationRelations to QualifierHierarchy
  Renamed GraphAnnotationRelations to GraphQualifierHierarchy
  Renamed TypeRelations to TypeHierarchy
  Added flow as a supported lint option for all checkers
  Determined the suppress warning key reflectively

Interned Checker
  Moved @Interned annotation to checkers.interned.quals package

NonNull Checker
  Moved nonnull annotations to checkers.nonnull.quals package

Miscellaneous
  Included Javadocs in the release
  Improved documentation for all checkers

----------------------------------------------------------------------
Version 0.6.2, 30 May 2008

Checker Framework API
  Added support for @Default annotation via TreeAnnotator
  Added support for PolymorphicQualifier meta-annotation
  Disallow the use of @SupportedAnnotationTypes on checkers
  Fixed bugs related to wildcards with super clauses
  Improved flow-sensitive analysis for fields

Javari Checker
  Moved Javari qualifiers from checkers.quals to checkers.javari.quals
  Fixed bugs causing null pointer exceptions

NonNull Checker
  Fixed bugs related to nonnull flow
  Added new tests to test suite

Basic Checker
  Renamed Custom Checker to Basic Checker

----------------------------------------------------------------------
Version 0.6.1, 26 Apr 2008

Checkers Framework API
  Added support for @ImplicitFor meta-annotations via the new TypeAnnotator
    and TreeAnnotator classes
  Improved documentation and specifications
  Fixed a bug related to getting supertypes of wildcards
  Fixed a crash on class literals of primitive and array types
  Framework ignores annotations that are not part of a type system
  Fixed several minor bugs in the flow-sensitive inference implementation.

IGJ Checker
  Updated the checker to use AnnotationRelations and TypeRelations

Javari Checker
  Changing RoMaybe annotation to PolyRead
  Updated checker to use AnnotationRelations and TypeRelations
  Updated the JDK
  Fixed bugs related to QReadOnly and type argument subtyping
  Fixed bugs related to this-mutable fields in methods with @ReadOnly receiver
  Fixed bugs related to primitive type casts
  Added new tests to test suit

NonNull Checker
  Updated the annotated JDK
  Fixed bugs in which default annotations were not correctly applied
  Added @Raw types to handle partial object initialization.
  Fixed several minor bugs in the checker implementation.

Custom Checker
  Updated checker to use hierarchy meta-annotations, via -Aquals argument

----------------------------------------------------------------------
Version 0.6, 11 Apr 2008

Checkers Framework API
  Introduced AnnotationRelations and TypeRelations, more robust classes to
    represent type and annotation hierarchies, and deprecated
    SimpleSubtypeRelation
  Add support for meta-annotations to declare type qualifiers subtype relations
  Re-factored AnnotatedTypes and AnnotatedTypeFactory
  Added a default implementation of SourceChecker.getSuppressWarningsKey()
    that reads the @SuppressWarningsKey class annotation
  Improved support for multidimensional arrays and new array expressions
  Fixed a bug in which implicit annotations were not being applied to
    parenthesized expressions
  Framework ignores annotations on a type that do not have @TypeQualifier
  Moved error/warning messages into "messages.properties" files in each
    checker package
  Fixed a bug in which annotations were inferred to liberally by
    checkers.flow.Flow

Interned Checker
  Added heuristics that suppress warnings for certain comparisons (namely in
    methods that override Comparator.compareTo and Object.equals)
  The Interned checker uses flow-sensitive inference by default

IGJ Checker
  Fixed bugs related to resolving immutability variable in method invocation
  Fixed a bug related to reassignability of fields
  Add more tests

Javari Checker
  Added placeholder annotation for ThisMutable mutability
  Re-factored JavariAnnotatedTypeFactory
  Fixed self-type resolution for method receivers for readonly classes
  Fixed annotations on parameters of readonly methods
  Fixed type validation for arrays of primitives
  Added more tests
  Renamed @RoMaybe annotation to @PolyRead

NonNull Checker
  Removed deprecated checkers.nonnull.flow package
  Fixed a bug in which default annotations were not applied correctly

Miscellaneous
  Improved Javadocs
  Added FactoryTestChecker, a more modular tester for the annotated type
    factory
  Simplify error output for some types by stripping package names

----------------------------------------------------------------------
Version 0.5.1, 21 Mar 2008

Checkers Framework API
  Added support for conditional expression
  Added checks for type validity and assignability
  Added support for checkers customization of asMemberOf
  Added support for type parameters in method invocation,
    including type inference
  Enhanced performance of AnnotatedTypeFactory
  Checkers run only when no errors are found by Javac
  Fixed bugs related AnnotationUtils.deepCopy()
  Fixed support for annotated class type parameters
  Fixed some support for annotated type variable bounds
  Added enhancements to flow-sensitive qualifier inference
  Added checks for type parameter bounds

Interned Checker
  Fixed some failing test cases
  Fixed a bug related to auto-boxing/unboxing
  Added experimental flow-sensitive qualifier inference (use
    "-Alint=flow" to enable)
  Improved subtype testing, removing some spurious errors

IGJ Checker
  Deleted IGJVisitor!
  Fixed some bugs related to immutability type variable resolution

Javari Checker
  Removed redundant methods from JavariVisitor in the new framework
  Added support to constructor receivers
  Added support to parenthesized expressions
  Fixed a bug related to resolving RoMaybe constructors
  Fixed a bug related to parsing conditional expressions
  Added parsing of parenthesized expressions
  Replaced checkers.javari.VisitorState with
    checkers.types.VisitorState, present in BaseTypeVisitor
  Modified JavariVisitor type parameters (it now extends
    BaseTypeVisitor<Void, Void>, not BaseTypeVisitor<Void,
    checkers.javari.VisitorState>)
  Modified JavariAnnotatedTypeFactory TreePreAnnotator to mutate a
    AnnotatedTypeMirror parameter instead of returning a
    List<AnnotationMirror>, in accordance with other parts of the
    framework design
  Modified test output format
  Added tests to test suite

NonNull Checker
  Fixed a bug related to errors produced on package declarations
  Exception parameters are now treated as NonNull by default
  Added better support for complex conditionals in NonNull-specific
    flow-sensitive inference
  Fixed some failing test cases
  Improved subtype testing, removing some spurious errors

Custom Checker
  Added a new type checker for type systems with no special semantics, for
    which annotations can be provided via the command line

Miscellaneous
  Made corrections and added more links to Javadocs
  A platform-independent binary version of the checkers and framework
    (checkers.jar) is now included in this release

----------------------------------------------------------------------
Version 0.5, 7 Mar 2008

Checkers Framework API
  Enhanced the supertype finder to take annotations on extends and
    implements clauses of a class type
  Fixed a bug related to checking an empty array initializer ("{}")
  Fixed a bug related to missing type information when multiple
    top-level classes are defined in a single file
  Fixed infinite recursion when checking expressions like "Enum<E
    extends Enum<E>>"
  Fixed a crash in checkers.flow.Flow related to multiple top-level
    classes in a single file
  Added better support for annotated wildcard type bounds
  Added AnnotatedTypeFactory.annotateImplicit() methods to replace
    overriding the getAnntoatedType() methods directly
  Fixed a bug in which constructor arguments were not checked

Interned Checker
  Fixed a bug related to auto-unboxing of classes for primitives
  Added checks for calling methods with an @Interned receiver

IGJ Checker
  Implemented the immutability inference for self-type (type of
    'this') properly
  Enhanced the implicit annotations to make an un-annotated code
    type-check
  Fixed bugs related to invoking methods based on a method's receiver
    annotations

Javari Checker
  Restored in this version, after porting to the new framework

NonNull Checker
  Fixed a bug in which primitive types were considered possibly null
  Improvements to support for @Default annotations

Miscellaneous
  Improved error message display for all checkers

----------------------------------------------------------------------
Version 0.4.1, 22 Feb 2008

Checkers Framework API
  Introduced AnnotatedTypeFactory.directSupertypes() which finds the
    supertypes as annotated types, which can be used by the framework.
  Introduced default error messages analogous to javac's error messages.
  Fixed bugs related to handling array access and enhanced-for-loop type
    testing.
  Fixed several bugs that are due AnnotationMirror not overriding .equals()
    and .hashCode().
  Improved Javadocs for various classes and methods.
  Fixed several bugs that caused crashes in the checkers.
  Fixed a bug where varargs annotations were not handled correctly.

IGJ Checker
  Restored in this version, after porting the checker to the new framework.

NonNull Checker
  Fixed a bug where static field accesses were not handled correctly.
  Improved error messages for the NonNull checker.
  Added the NNEL (NonNull Except Locals) annotation default.

Interned Checker
  Fixed a bug where annotations on type parameter bounds were not handled
    correctly.
  Improved error messages for the Interned checker.

----------------------------------------------------------------------
Version 0.4, 11 Feb 2008

Checkers Framework API
  Added checkers.flow, an improved and generalized flow-sensitive type
    qualifier inference, and removed redundant parts from
    checkers.nonnull.flow.
  Fixed a bug that prevented AnnotatedTypeMirror.removeAnnotation from working
    correctly.
  Fixed incorrect behavior in checkers.util.SimpleSubtypeRelation.

NonNull Checker
  Adopted the new checkers.flow.Flow type qualifier inference.
  Clarifications and improvements to Javadocs.

----------------------------------------------------------------------
Version 0.3.99, 20 Nov 2007

Checkers Framework API
  Deprecated AnnotatedClassType, AnnotatedMethodType, and AnnotationLocation
    in favor of AnnotatedTypeMirror (a new representation of annotated types
    based on the javax.lang.model.type hierarchy).
  Added checkers.basetype, which provides simple assignment and
    pseudo-assignment checking.
  Deprecated checkers.subtype in favor of checkers.basetype.
  Added options for debugging output from checkers: -Afilenames, -Ashowchecks

Interned Checker
  Adopted the new checkers framework API.
  Fixed a bug in which "new" expressions had an incorrect type.

NonNull Checker
  Adopted the new checkers framework API.

Javari Checker
IGJ Checker
  Removed in this version, to be restored in a future version pending
    completion of updates to these checkers with respect to the new framework
    API.

----------------------------------------------------------------------
Version 0.3, 1 Oct 2007

Miscellaneous Changes
  Consolidated HTML documentation into a single user manual (see the "manual"
    directory in the distribution).

IGJ Checker
  New features:
    Added a test suite.
    Added annotations (skeleton files) for parts of java.util and java.lang.

NonNull Checker
  New features:
    @SuppressWarnings("nonnull") annotation suppresses checker warnings.
    @Default annotation can make NonNull (not Nullable) the default.
    Added annotations (skeleton classes) for parts of java.util and java.lang.
    NonNull checker skips no classes by default (previously skipped JDK).
    Improved error messages: checker reports expected and found types.

  Bug fixes:
    Fixed a null-pointer exception when checking certain array accesses.
    Improved checking for field dereferences.

Interned Checker
  New features:
    @SuppressWarnings("interned") annotation suppresses checker warnings.
    The checker warns when two @Interned objects are compared with .equals

  Bug fixes:
    The checker honors @Interned annotations on method receivers.
    java.lang.Class types are treated as @Interned.

Checkers Framework API
  New features:
    Added support for default annotations and warning suppression in checkers

----------------------------------------------------------------------
Version 0.2.3, 30 Aug 2007

IGJ Checker
  New features:
    changed @W(int) annotation to @I(String) to improve readability
    improved readability of error messages
    added a test for validity of types (testing @Mutable String)

  Bug fixes:
    fixed resolving of @I on fields on receiver type
    fixed assignment checking assignment validity for enhanced for loop
    added check for constructor invocation parameters

Interned Checker
  added the Interned checker, for verifying the absence of equality testing
    errors; see "interned-checker.html" for more information

Javari Checker
  New features:
    added skeleton classes for parts of java.util and java.lang with Javari
      annotations

  Bug fixes:
    fixed readonly inner class bug on Javari checker

NonNull Checker
  New features:
    flow-sensitive analysis for assignments from a known @NonNull type (e.g.,
      when the right-hand of an assignment is @NonNull, the left-hand is
      considered @NonNull from the assignment to the next possible
      reassignment)
    flow-sensitive analysis within conditional checks

  Bug fixes:
    fixed several sources of null-pointer errors in the NonNull checker
    fixed a bug in the flow-sensitive analysis when a variable was used on
      both sides of the "=" operator

Checkers Framework API
  New features:
    added the TypesUtils.toString() method for pretty-printing annotated types
    added AnnotationUtils, a utility class for working with annotations and
      their values
    added SourceChecker.getDefaultSkipPattern(), so that checkers can
      individually specify which classes to skip by default
    added preliminary support for suppressing checker warnings via
      the @SuppressWarnings annotation

  Bug fixes:
    fixed handling of annotations of field values
    InternalAnnotation now correctly uses defaults for annotation values
    improved support for annotations on class type parameter bounds
    fixed an assertion violation when compiling certain uses of arrays

----------------------------------------------------------------------
Version 0.2.2, 16 Aug 2007


Code Changes

* checkers.igj
    some bug fixes and improved documentation

* checkers.javari
    fixed standard return value to be @Mutable
    fixed generic and array handling of @ReadOnly
    fixed @RoMaybe resolution of receivers at method invocation
    fixed parsing of parenthesized trees and conditional trees
    added initial support for for-enhanced loop
    fixed constructor behavior on @ReadOnly classes
    added checks for annotations on primitive types inside arrays

* checkers.nonnull
    flow sensitive analysis supports System.exit, new class/array creation

* checkers.subtype
    fixes for method overriding and other generics-related bugs

* checkers.types
    added AnnotatedTypeMirror, a new representation for annotated types that
      might be moved to the compiler in later version
    added AnnotatedTypeScanner and AnnotatedTypeVisitor, visitors for types
    AnnotatedTypeFactory uses GenericsUtils for improved handing of annotated
      generic types

* checkers.util
    added AnnotatedTypes, a utility class for AnnotatedTypeMirror
    added GenericsUtils, a utility class for working with generic types

* tests
    modified output to print only missing and unexpected diagnostics
    added new test cases for the Javari checker


Documentation Changes

* checkers/igj-checker.html
    improvements to page

* checkers/javari-checker.html
    examples now point to test suit files

Miscellaneous Changes

* checkers/build.xml
    Ant script fails if it doesn't find the correct JSR 308 javac version

----------------------------------------------------------------------
Version 0.2.1, 1 Aug 2007


Code Changes

* checkers.igj & checkers.igj.quals
    added an initial implementation for the IGJ language

* checkers.javari
    added a state parameter to the visitor methods
    added tests and restructured the test suite
    restructured and implemented RoMaybe
    modified return type to be mutable by default
    fixed mutability type handling for type casts and field access
    fixed bug, ensuring no primitives can be ReadOnly
    a method receiver type is now based on the correct annotation
    fixed parameter type checking for overriden methods
    fixed bug on readonly field initialization
    added handling for unary trees

* checkers.nonnull
    added a tests for the flow-senstive analysis and varargs methods
    improved flow-sensitive analysis: else statements, asserts,
      return/throw statements, instanceof checks, complex conditionals with &&
    fixed a bug in the flow-sensitive analysis that incorrectly inferred
      @NonNull for some elements
    removed NonnullAnnotatedClassType, moving its functionality into
      NonnullAnnotatedTypeFactory

* checkers.source
    SourceChecker.getSupportedAnnotationTypes() returns ["*"], overriding
      AbstractProcessor.getSupportedAnnotationTypes(). This enables all
      checkers to run on unannotated code

* checkers.subtypes
    fixed a bug pertaining to method parameter checks for overriding methods
    fixed a bug that caused crashes when checking varargs methods

* checkers.types
    AnnotatedTypeFactory.getClass(Element) and getMethod(Element) use the
      tree of the passed Element if one exists
    AnnotatedClassType.includeAt, .execludeAt, .getAnnotationData were
      added and are public
    added constructor() and skipParens() methods to InternalUtils
    renamed getTypeArgumentLocations() to getAnnotatedTypeArgumentLocations()
      in AnnotatedClassType
    added AnnotationData to represent annotations instead of Class instances;
      primarily allows querying annotation arguments
    added switch for whether or not to use includes/excludes in
      AnnotatedClassType.hasAnnotationAt()

* checkers.util
    added utility classes
    added skeleton class generator utility for annotating external libraries


Documentation Changes

* checkers/nonnull-checker.html
    added a note about JML
    added a caveat about variable initialization

* checkers/README-checkers.html
    improvements to instructions

----------------------------------------------------------------------
Version 0.2, 2 Jul 2007


Code Changes

* checkers.subtype
    subtype checker warns for annotated and redundant typecasts
    SubtypeVisitor checks for invalid return and parameter types in overriding
      methods
    added checks for compound assignments (like '+=')

* checkers.source
    SourceChecker honors the "checkers.skipClasses" property as a regex for
      suppressing warnings from unannotated code (property is "java.*" by
      default)
    SourceVisitor extends TreePathScanner<R,P> instead of
      TreeScanner<Void,Void>

* checkers.types
    AnnotatedClassType.isAnnotatedWith removed
    AnnotatedClassType.getInnerLocations renamed to getTypeArgumentLocations
    AnnotatedClassType.include now removes from the exclude list (and
      vice-versa)
    AnnotatedClassType.setElement and setTree methods are now public

* checkers.nonnull
    added a flow-sensitive analysis for inferring @NonNull in "if (var !=
      null)"-style checks
    added checks for prefix and postfix increment and decrement operations

* checkers.javari
    added initial implementation of a typechecker for the Javari language

----------------------------------------------------------------------
Version 0.1.1, 7 Jun 2007


Documentation Changes

* checkers/nonnull-checker.html
    created "Tiny examples" subsection
    created "Annotated library" subsection
    noted where to read @NonNull-annotated source
    moved instructions for unannotated code to README-checkers.html
    various minor corrections and clarifications

* checkers/README-checkers.html
    added cross-references to other checkers documents
    removed redundant text
    moved instructions for unannotated code from nonnull-checker.html
    various minor corrections and clarifications

* checkers/creating-a-checker.html
    added note about getSupportedSourceVersion
    removed line numbers from @Interned example
    added section on SubtypeChecker/SubtypeVisitor
    various minor corrections and clarifications


Code Changes

* checkers.subtype
    removed deprecated getCheckedAnnotation() mechanism
    added missing package Javadocs
    package Javadocs reference relevant HTML documentation
    various improvements to Javadocs
    SubtypeVisitor and SubtypeChecker are now abstract classes
    updated with respect to preferred usages of
      AnnotatedClassType.hasAnnotationAt and AnnotatedClassType.annotateAt

* checkers.source
    added missing package Javadocs
    package Javadocs reference relevant HTML documentation

* checkers.types
    added missing package Javadocs
    package Javadocs reference relevant HTML documentation
    AnnotatedClassType.annotateAt now correctly handles
      AnnotationLocation.RAW argument
    AnnotatedClassType.annotate deprecated in favor of
      AnnotatedClassType.annotateAt with AnnotationLocation.RAW as an argument
    AnnotatedClassType.isAnnotatedWith deprecated in favor of
      AnnotatedClassType.hasAnnotationAt with AnnotationLocation.RAW as an
      argument
    Added fromArray and fromList methods to AnnotationLocation and made
      corresponding constructors private.

* checkers.quals
    added Javadocs and meta-annotations on annotation declarations where
      missing
    package Javadocs reference relevant HTML documentation

* checkers.nonnull
    various improvements to Javadocs
    package Javadocs reference relevant HTML documentation


Miscellaneous Changes

    improved documentation of checkers examples
    checkers build file now only attempts to compile .java files


----------------------------------------------------------------------
Version 0.1.0, 1 May 2007

Initial release.