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, not BaseTypeVisitor) Modified JavariAnnotatedTypeFactory TreePreAnnotator to mutate a AnnotatedTypeMirror parameter instead of returning a List, 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>" 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 instead of TreeScanner * 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.