Version 2.1.12, 1 June 2017 The manual links to Glacier, a class immutability checker. The stubparser license has been updated. You can now use stubparser under either the LGPL or the Apache license, whichever you prefer. Closed issues: 254, 1201, 1229, 1236, 1239, 1240, 1257, 1265, 1270, 1271, 1272, 1274, 1288, 1291, 1299, 1304, 1305. --------------------------------------------------------------------------- Version 2.1.11, 1 May 2017 The manual contains new FAQ (frequently asked questions) sections about false positive warnings and about inference for field types. Closed issues: 989, 1096, 1136, 1228. --------------------------------------------------------------------------- Version 2.1.10, 3 April 2017 The Constant Value Checker, which performs constant propagation, has been extended to perform interval analysis -- that is, it determines, for each expression, a statically-known lower and upper bound. Use the new @IntRange annotation to express this. Thanks to Jiasen (Jason) Xu for this feature. Closed issues: 134, 216, 227, 307, 334, 437, 445, 718, 1044, 1045, 1051, 1052, 1054, 1055, 1059, 1077, 1087, 1102, 1108, 1110, 1111, 1120, 1124, 1127, 1132. --------------------------------------------------------------------------- Version 2.1.9, 1 March 2017 By default, uninferred method type arguments, which can happen with Java 8 style target type contexts, are silently ignored, removing many false positives. The new option -AconservativeUninferredTypeArguments can be used to get the conservative behavior. Closed issues: 1006, 1011, 1015, 1027, 1035, 1036, 1037, 1039, 1043, 1046, 1049, 1053, 1072, 1084. --------------------------------------------------------------------------- Version 2.1.8, 20 January 2017 The Checker Framework webpage has moved to https://checkerframework.org/. Old URLs should redirect to the new one, but please update your links and let us know if any old links are broken rather than redirecting. The documentation has been reorganized in the Checker Framework repository. The manual, tutorial, and webpages now appear under checker-framework/docs/. Closed issues: 770, 1003, 1012. --------------------------------------------------------------------------- Version 2.1.7, 3 January 2017 Manual improvements: * Added a link to jOOQ's SQL checker. * Documented the `-AprintVerboseGenerics` command-line option. * Better explanation of relationship between Fake Enum and Subtyping Checkers. Closed issues: 154, 322, 402, 404, 433, 531, 578, 720, 795, 916, 953, 973, 974, 975, 976, 980, 988, 1000. --------------------------------------------------------------------------- Version 2.1.6, 1 December 2016 Closed issues: 412, 475. --------------------------------------------------------------------------- Version 2.1.5, 2 November 2016 The new class org.checkerframework.checker.nullness.Opt provides every method in Java 8's java.util.Optional class, but written for possibly-null references rather than for the Optional type. This can shorten code that manipulates possibly-null references. In bytecode, type variable upper bounds of type Object may or may not have been explicitly written. The Checker Framework now assumes they were not written explicitly in source code and defaults them as implicit upper bounds. The manual describes how to run a checker within the NetBeans IDE. The manual describes two approaches to creating a type alias or typedef. Closed issues: 643, 775, 887, 906, 941. --------------------------------------------------------------------------- Version 2.1.4, 3 October 2016 Closed issues: 885, 886, 919. --------------------------------------------------------------------------- Version 2.1.3, 16 September 2016 Closed issues: 122, 488, 495, 580, 618, 647, 713, 764, 818, 872, 893, 894, 901, 902, 903, 905, 913. --------------------------------------------------------------------------- Version 2.1.2, 1 September 2016 Closed issues: 182, 367, 712, 811, 846, 857, 858, 863, 870, 871, 878, 883, 888. --------------------------------------------------------------------------- Version 2.1.1, 1 August 2016 The codebase conforms to a consistent coding style, which is enforced by a git pre-commit hook. AnnotatedTypeFactory#createSupportedTypeQualifiers() must now return a mutable list. Checkers that override this method will have to be changed. Closed issues: 384, 590, 681, 790, 805, 809, 810, 820, 824, 826, 829, 838, 845, 850, 856. --------------------------------------------------------------------------- Version 2.1.0, 1 July 2016 The new Signedness Checker prevents mixing of unsigned and signed values and prevents meaningless operations on unsigned values. The Lock Checker expresses the annotated variable as ``; previously it used `itself`, which may conflict with an identifier. Closed issues: 166, 273, 358, 408, 471, 484, 594, 625, 692, 700, 701, 711, 717, 752, 756, 759, 763, 767, 779, 783, 794, 807, 808. --------------------------------------------------------------------------- Version 2.0.1, 1 June 2016 We renamed method annotateImplicit to addComputedTypeAnnotations. If you have implemented a checker, you need to change occurrences of annotateImplicit to addComputedTypeAnnotations. The Checker Framework (checker.jar) is now placed on the processorpath during compilation. Previously, it was placed on the classpath. The qualifiers (checker-qual.jar) remain on the classpath. This change should reduce conflicts between your code and the Checker Framework. If your code depends on classes in the Checker Framework, then you should add those classes to the classpath when you run the compiler. Closed issues: 171, 250, 291, 523, 577, 672, 680, 688, 689, 690, 691, 695, 696, 698, 702, 704, 705, 706, 707, 720, 721, 723, 728, 736, 738, 740. --------------------------------------------------------------------------- Version 2.0.0, 2 May 2016 Inference: * The infer-and-annotate.sh script infers annotations and inserts them in your source code. This can reduce the burden of writing annotations and let you get started using a type system more quickly. See the "Whole-program inference" section in the manual for details. Type systems: * The Lock Checker has been replaced by a new implementation that provides a stronger guarantee. The old Lock Checker prevented two threads from simultaneously using a given variable, but race conditions were still possible due to aliases. The new Lock Checker prevents two threads from simultaneously dereferencing a given value, and thus prevents race conditions. For details, see the "Lock Checker" chapter in the manual, which has been rewritten to describe the new semantics. * The top type qualifier for the Signature String type system has been renamed from @UnannotatedString to @SignatureUnknown. You shouldn't ever write this annotation, but if you perform separate compilation (for instance, if you do type-checking with the Signature String Checker against a library that is annotated with Signature String annotations), then you need to re-compile the library. * The IGJ, OIGJ, and Javari Checkers are no longer distributed with the Checker Framework. If you wish to use them, install version 1.9.13 of the Checker Framework. The implementations have been removed because they were not being maintained. The type systems are valuable, but the type-checkers should be rewritten from scratch. Documentation improvements: * New manual section "Tips for creating a checker" shows how to break down the implementation of a type system into small, manageable pieces. * Improved instructions for using Maven and Gradle, including for Android code. Tool changes: * The Checker Framework Live Demo webpage lets you try the Checker Framework without installing it: http://eisop.uwaterloo.ca/live/ * New command-line arguments -Acfgviz and -Averbosecfg enable better debugging of the control-flow-graph generation step of type-checking. * New command-line argument -Ainfer is used by the infer-and-annotate.sh script that performs type inference. Closed issues: 69, 86, 199, 299, 329, 421, 428, 557, 564, 573, 579, 665, 668, 669, 670, 671. --------------------------------------------------------------------------- Version 1.9.13, 1 April 2016 Documentation: * Clarified Maven documentation about use of annotations in comments. * Added FAQ about annotating fully-qualified type names. Closed issues: 438, 572, 579, 607, 624, 631. --------------------------------------------------------------------------- Version 1.9.12, 1 March 2016 The Checker Framework distribution contains annotated versions of libraries in directory checker-framework/checker/lib/. During type-checking, you should put these versions first on your classpath, to obtain more precise type-checking with fewer false positive warnings. tools.jar is no longer required to be on the classpath when using checker-qual.jar The Signature String Checker supports two new string representations of a Java type: @InternalForm and @ClassGetSimpleName. The manual documents how to run a pluggable type-checker in IntelliJ IDEA. The instructions on how to run a type-checker in Gradle have been updated to use the artifacts in Maven Central. Examples using the instructions have been added under checker-framework/docs/examples/GradleExamples/. Renamed enum DefaultLocation to TypeUseLocation. Closed issues: 130, 263, 345, 458, 559, 559, 574, 582, 596. --------------------------------------------------------------------------- Version 1.9.11, 1 February 2016 Renamed and merged -AuseSafeDefaultsForUnannotatedSourceCode and -AsafeDefaultsForUnannotatedBytecode command-line options to -AuseDefaultsForUncheckedCode that takes arguments source and bytecode. For type-system developers: * The previously deprecated org.checkerframework.framework.qual.TypeQualifier{s} annotations were removed. * Every type system uses the CLIMB-to-top defaulting scheme, unless it explicitly specifies a different one. Previously a type system needed to explicitly request CLIMB-to-top, but now it is the default. Closed issues: 524, 563, 568. --------------------------------------------------------------------------- Version 1.9.10, 4 January 2016 The Checker Framework distribution files now contain a version number: for example, checker-framework-1.9.9.zip rather than checker-framework.zip. Nullness Checker supports org.eclipse.jgit.annotations.Nullable and NonNull annotations. Buildfiles do less unnecessary recomputation. Documentation: * Documented how to initialize circular data structures in the Initialization type system. * Linked to David Bürgin's Nullness Checker tutorial at https://github.com/glts/safer-spring-petclinic/wiki * Acknowledged more contributors in the manual. For type-system developers: * The org.checkerframework.framework.qual.TypeQualifier{s} annotations are now deprecated. To indicate which annotations a checker supports, see https://checkerframework.org/manual/#creating-indicating-supported-annotations . Support for TypeQualifier{s} will be removed in the next release. * Renamed org.checkerframework.framework.qual.Default{,Qualifier}ForUnannotatedCode to DefaultInUncheckedCodeFor and DefaultQualifierInHierarchyInUncheckedCode. Closed issues: 169, 363, 448, 478, 496, 516, 529. --------------------------------------------------------------------------- Version 1.9.9, 1 December 2015 Fixed issues: 511, 513, 514, 455, 527. Removed the javac_maven script and batch file, which had been previously deprecated. --------------------------------------------------------------------------- Version 1.9.8, 9 November 2015 Field initialization warnings can now be suppressed for a single field at a time, by placing @SuppressWarnings("initialization") on the field declaration. Updated Maven instructions to no longer require a script. Added an example of how to use the instructions under docs/examples/MavenExample. The javac_maven script (and batch file) are deprecated and will be removed as of December 2015. Fixed issues: 487, 500, 502. --------------------------------------------------------------------------- Version 1.9.7, 24 October 2015 Fixed issues: 291, 474. ---------------------------------------------------------------------- Version 1.9.6, 8 October 2015 Fixed issue: 460. ---------------------------------------------------------------------- Version 1.9.5, 1 September 2015 Test Framework Updates: * The test framework has been refactored to improve extensibility. * Tests that previously extended ParameterizedCheckerTest or CheckerTest should extend either CheckerFrameworkTest or nothing. * If a test used methods that were previously found on CheckerTest, you may find them in TestUtilities. Fixed issues: 438, 457, 459. ---------------------------------------------------------------------- Version 1.9.4, 4 August 2015 Documented the notion of a compound checker, which depends on other checkers and automatically runs them. Renamed -AuseConservativeDefaultsForUnannotatedSourceCode command-line option to -AuseSafeDefaultsForUnannotatedSourceCode Moved the Checker Framework version control repository from Google Code to GitHub, and from the Mercurial version control system to Git. If you have cloned the old repository, then discard your old clone and create a new one using this command: git clone https://github.com/typetools/checker-framework.git Fixed issues: 427, 429, 434, 442, 450. ---------------------------------------------------------------------- Version 1.9.3, 1 July 2015 New command-line options: * -AsafeDefaultsForUnannotatedBytecode causes a checker to use conservative defaults for .class files that were compiled without running the given checker. Without this option, type-checking is unsound (that is, there might be errors at run time even though the checker issues no warnings). * -AuseConservativeDefaultsForUnannotatedSourceCode uses conservative annotations for unannotated type uses. Use this when compiling a library in which some but not all classes are annotated. Various bug fixes and documentation improvements. Fixed issues: 436. ---------------------------------------------------------------------- Version 1.9.2, 1 June 2015 Internationalization Format String Checker: This new type-checker prevents use of incorrect internationalization format strings. Fixed issues: 434. ---------------------------------------------------------------------- Version 1.9.1, 1 May 2015 New FAQ entry: "How does the Checker Framework compare with Eclipse's null analysis?" ---------------------------------------------------------------------- Version 1.9.0, 17 April 2015 Bug fixes for generics, especially type parameters: * Manual chapter 21 "Generics and polymorphism" has been expanded, and it gives more information on annotating type parameters. * The qualifier on a type parameter (e.g. <@HERE T> ) only applies to the lower bound of that type parameter. Previously it also applied to the upper bound. * Unannotated, unbounded wildcards are now qualified with the annotations of the type parameter to which they are an argument. See the new manual section 23.3.4 for more details. * Warning "bound.type.incompatible" is issued if the lower bound of a type parameter or wildcard is a supertype of its upper bound, e.g. <@Nullable T extends @NonNull Object> * Method type argument inference has been improved. Fewer warnings should be issued when method invocations omit type arguments. * Added command-line option -AprintVerboseGenerics to print more information about type parameters and wildcards when they appear in warning messages. Reflection resolution: If you supply the -AresolveReflection command-line option, the Checker Framework attempts to resolve reflection. This reduces the number of false positive warnings caused by reflection. The documentation for the Map Key Checker has been moved into its own chapter in the manual. Fixed issues: 221, 241, 313, 314, 328, 335, 337, 338, 339, 355, 369, 376, 378, 386, 388, 389, 393, 403, 404, 413, 414, 415, 417, 418, 420, 421, 422, 426. ---------------------------------------------------------------------- Version 1.8.11, 2 March 2015 Fixed issues: 396, 400, 401. ---------------------------------------------------------------------- Version 1.8.10, 30 January 2015 Fixed issues: 37, 127, 350, 364, 365, 387, 392, 395. ---------------------------------------------------------------------- Version 1.8.9, 19 December 2014 Aliasing Checker: This new type-checker ensures that an expression has no aliases. Fixed issues: 362, 380, 382. ---------------------------------------------------------------------- Version 1.8.8, 26 November 2014 @SuppressWarnings("all") suppresses all Checker Framework warnings. Implicit imports are deprecated, including the jsr308_imports environment variable and the -jsr308_imports ... and -Djsr308.imports=... command-line options. For checkers bundled with the Checker Framework, package names may now be omitted when running from the command line. E.g. javac -processor NullnessChecker MyFile.java The Nullness checker supports Android annotations android.support.annotation.NonNull and android.support.annotation.Nullable. Fixed issues: 366, 379. ---------------------------------------------------------------------- Version 1.8.7, 30 October 2014 Fix performance regression introduced in release 1.8.6. Nullness Checker: * Updated Nullness annotations in the annotated JDK. See issues: 336, 340, 374. * String concatenations with null literals are now @NonNull rather than @Nullable. See issue 357. Fixed issues: 200, 300, 332, 336, 340, 357, 359, 373, 374. ---------------------------------------------------------------------- Version 1.8.6, 25 September 2014 Method Reference and Lambda Expression Support: The Checker Framework now supports type-checking method references and lambda expressions to ensure they are congruent with the functional interface they are assigned to. The bodies of lambda expressions are also now type-checked similarly to regular method bodies. Dataflow: * Handling of the following language features has been improved: boxed Booleans, finally blocks, switch statements, type casts, enhanced for loops * Performance improvements Annotations: The checker-compat-qual.jar is now included with the Checker Framework release. It can also be found in Maven Central at the coordinates: org.checkerframework:checker-compat-qual Annotations in checker-compat-qual.jar do not require Java 8 but can only be placed in annotation locations valid in Java 7. ---------------------------------------------------------------------- Version 1.8.5, 29 August 2014 Eclipse Plugin: All checkers in the Checker Framework manual now appear in the Eclipse plugin by default. Users no longer have to include checker.jar on their classpath to run any of the built-in checkers. Improved Java 7 compatibility and introduced Java 7 compliant annotations for the Nullness Checker. Please see the section on "Class-file compatibility with Java 7" in the manual for more details. Fixed issue 347. ---------------------------------------------------------------------- Version 1.8.4, 1 August 2014 The new Constant Value Checker is a constant propagation analysis: it determines which variable values can be known at compile time. Overriding methods now inherit declaration annotations from methods they override, if the declaration annotation is meta-annotate with @InheritedAnnotation. In particular, the purity annotations @SideEffectFree, @Deterministic, and @Pure are inherited. Command-line options: * Renamed the -AenablePurity command-line flag to -AcheckPurityAnnotations. * Added a command-line option -AoutputArgsToFile to output all command-line options passed to the compiler to a file. This is especially useful when debugging Maven compilation. Annotations: These changes are relevant only to people who wish to use pluggable type-checking with a standard Java 7 toolset. (If you are not having trouble with your Java 7 JVM, then you don't care about them.) * Made clean-room reimplementations of nullness-related annotations compatible with Java 7 JVMs, by removing TYPE_USE as a target. * Added a new set of Java 7 compatibility annotations for the Nullness Checker in the org.checkerframework.checker.nullness.compatqual package. These annotations do not require Java 8 but can only be placed in annotation locations valid in Java 7. Java 8 support: The Checker Framework no longer crashes when type-checking code with lambda expressions, but it does issue a lambda.unsupported warning when type-checking code containing lambda expressions. Full support for type-checking lambda expressions will appear in a future release. Fixed issue 343. ---------------------------------------------------------------------- Version 1.8.3, 1 July 2014 Updated the Initialization Checker section in the manual with a new introduction paragraph. Removed the Maven plugin section from the manual as the plugin is no longer maintained and the final release was on June 2, 2014. The javac_maven script (and batch file) are available to use the Checker Framework from Maven. Fixed issue 331. ---------------------------------------------------------------------- Version 1.8.2, 2 Jun 2014 Converted from using rt.jar to ct.sym for creating the annotated jdk. Using the annotated jdk on the bootclasspath of a VM will cause the vm to crash immediately. The Lock Checker has been rewritten to support dataflow analysis. It can now understand conditional expressions, for example, and knows that "lock" is held in the body of statements like "if (lock.tryLock()) { ... }" The Lock Checker chapter in the manual has been updated accordingly and describes the new Lock Checker features in detail. Provided a javac_maven script (and batch file) to make it simpler to use the Checker Framework from Maven. The Maven plug-in is deprecated and will be removed as of July 1, 2014. Added an explanation of how to use the script in the Maven section of the manual. The Checker Framework installation instructions in the manual have been updated. Fixed issues: 312, 315, 316, 318, 319, 324, 326, 327. ---------------------------------------------------------------------- Version 1.8.1, 1 May 2014 Support to directly use the Java 8 javac in addition to jsr308-langtools. Added docs/examples directory to checker-framework.zip. New section in the manual describing the contents of checker-framework.zip. Fixed issues: 204, 304, 320. ---------------------------------------------------------------------- Version 1.8.0, 2 April 2014 Added the GUI Effect Checker, which prevents "invalid thread access" errors when a background thread in a GUI attempts to access the UI. Changed the Java package of all type-checkers and qualifiers. The package "checkers" has been renamed to "org.checkerframeork.checker". This requires you to change your import statements, such as from import checkers.nullness.quals.*; to import org.checkerframework.checker.nullness.qual.*; It also requires you to change command-line invocations of javac, such as from javac -processor checkers.nullness.NullnessChecker ... to javac -processor org.checkerframework.checker.nullness.NullnessChecker ... Restructured the Checker Framework project and package layout, using the org.checkerframework prefix. ---------------------------------------------------------------------- Version 1.7.5, 5 March 2014 Minor improvements to documentation and demos. Support a few new units in the UnitsChecker. ---------------------------------------------------------------------- Version 1.7.4, 19 February 2014 Error messages now display the error key that can be used in SuppressWarning annotations. Use -AshowSuppressWarningKeys to show additional keys. Defaulted type qualifiers are now stored in the Element and written to the final bytecode. Reduce special treatment of checkers.quals.Unqualified. Fixed issues: 170, 240, 265, 281. ---------------------------------------------------------------------- Version 1.7.3, 4 February 2014 Fixes for Issues 210, 253, 280, 288. Manual: Improved discussion of checker guarantees. Maven Plugin: Added option useJavacOutput to display exact compiler output. Eclipse Plugin: Added the Format String Checker to the list of built-in checkers. ---------------------------------------------------------------------- Version 1.7.2, 2 January 2014 Fixed issues: 289, 292, 295, 296, 298. ---------------------------------------------------------------------- Version 1.7.1, 9 December 2013 Fixes for Issues 141, 145, 257, 261, 269, 267, 275, 278, 282, 283, 284, 285. Implementation details: Renamed AbstractBasicAnnotatedTypeFactory to GenericAnnotatedTypeFactory ---------------------------------------------------------------------- Version 1.7.0, 23 October 2013 Format String Checker: This new type-checker ensures that format methods, such as System.out.printf, are invoked with correct arguments. Renamed the Basic Checker to the Subtyping Checker. Reimplemented the dataflow analysis that performs flow-sensitive type refinement. This fixes many bugs, improves precision, and adds features. Many more Java expressions can be written as annotation arguments. Initialization Checker: This new abstract type-checker verifies initialization properties. It needs to be combined with another type system whose proper initialization should be checked. This is the new default initialzation checker for the Nullness Checker. It is based on the "Freedom Before Commitment" approach. Renamed method annotations used by the Nullness Checker: @AssertNonNullAfter => @EnsuresNonNull @NonNullOnEntry => @RequiresNonNull @AssertNonNullIfTrue(...) => @IfMethodReturnsFalseEnsuresNonNull @AssertNonNullIfFalse(...) => @IfMethodReturnsFalseEnsuresNonNull @LazyNonNull => @MonotonicNonNull @AssertParametersNonNull => [no replacement] Removed annotations used by the Nullness Checker: @AssertParametersNonNull Renamed type annotations used by the Initialization Checker: @NonRaw => @Initialized @Raw => @UnknownInitialization new annotation @UnderInitialization The old Initialization Checker (that uses @Raw and @NonRaw) can be invoked by invoking the NullnessRawnessChecker rather than the NullnessChecker. Purity (side effect) analysis uses new annotations @SideEffectFree, @Deterministic, and @TerminatesExecution; @Pure means both @SideEffectFree and @Deterministic. Pre- and postconditions about type qualifiers are available for any type system through @RequiresQualifier, @EnsuresQualifier and @EnsuresQualifierIf. The contract annotations for the Nullness Checker (e.g. @EnsuresNonNull) are now only a special case of these general purpose annotations. The meta-annotations @PreconditionAnnotation, @PostconditionAnnotation, and @ConditionalPostconditionAnnotation can be used to create more special-case annotations for other type systems. Renamed assertion comment string used by all checkers: @SuppressWarnings => @AssumeAssertion To use an assert statement to suppress warnings, the assertion message must include the string "@AssumeAssertion(warningkey)". Previously, just the warning key sufficed, but the string @SuppressWarnings(warningkey) was recommended. New command-line options: -AonlyDefs and -AonlyUses complement existing -AskipDefs and -AskipUses -AsuppressWarnings Suppress warnings matching the given key -AassumeSideEffectFree Unsoundly assume that every method is side-effect-free -AignoreRawTypeArguments Ignore subtype tests for type arguments that were inferred for a raw type -AenablePurity Check the bodies of methods marked as pure (@SideEffectFree or @Deterministic) -AsuggestPureMethods Suggest methods that could be marked as pure -AassumeAssertionsAreEnabled, -AassumeAssertionsAreDisabled Whether to assume that assertions are enabled or disabled -AconcurrentSemantics Whether to assume concurrent semantics -Anocheckjdk Don't err if no annotated JDK can be found -Aflowdotdir Create an image of the control flow graph -AinvariantArrays replaces -Alint=arrays:invariant -AcheckCastElementType replaces -Alint=cast:strict Manual: New manual section about array types. New FAQ entries: "Which checker should I start with?", "How can I handle typestate, or phases of my program with different data properties?", "What is the meaning of a type qualifier at a class declaration?" Reorganized FAQ chapter into sections. Many other improvements. ---------------------------------------------------------------------- Version 1.6.7, 28 August 2013 User-visible framework improvements: Improve the error message produced by -Adetailedmsgtext Bug fixes: Fix issue #245: anonymous classes were skipped by default ---------------------------------------------------------------------- Version 1.6.6, 01 August 2013 Documentation: The Checker Framework manual has been improved. Changes include: more troubleshooting tips to the Checker Framework manual, an improved discussion on qualifier bounds, more examples, improved formatting, and more. An FAQ entry has been added to discuss JSR305. Minor clarifications have been added to the Checker Framework tutorial. ---------------------------------------------------------------------- Version 1.6.5, 01 July 2013 User-visible framework improvements: Stub files now support static imports. Maven plugin: Maven plugin will now issue a warning rather than quit when zero checkers are specified in a project's pom.xml. Documentation: Improved the Maven plugin instructions in the Checker Framework manual. Added documentation for the -XDTA:noannotationsincomments compiler flag. Internal framework improvements: Improved Maven-plugin developer documentation. ---------------------------------------------------------------------- Version 1.6.4, 01 June 2013 User-visible framework improvements: StubGenerator now generates stubs that can be read by the StubParser. Maven plugin: The Maven plugin no longer requires the Maven project's output directory to exist in order to run the Checker Framework. However, if you ask the Checker Framework to generate class files then the output directory will be created. Documentation: Improved the Maven plugin instructions in the Checker Framework manual. Improved the discussion of why to define both a bottom and a top qualifier in the Checker Framework manual. Update FAQ to discuss that some other tools incorrectly interpret array declarations. ---------------------------------------------------------------------- Version 1.6.3, 01 May 2013 Eclipse plugin bug fixes: The javac argument files used by the Eclipse plugin now properly escape file paths. Windows users should no longer encounter errors about missing built-in checkers. Documentation: Add FAQ "What is the meaning of an annotation after a type?" ---------------------------------------------------------------------- Version 1.6.2, 04 Apr 2013 Eclipse plugin: The "Additional compiler parameters" text field has now been replaced by a list. Parameters in this list may be activated/deactivated via checkbox. Eclipse plugin bug fixes: Classpaths and source files should now be correctly quoted when they contain spaces. Internal framework improvements: Update pom files to use the same update-version code as the Checker Framework "web" ant task. Remove pom specific update-version code. Update build ant tasks to avoid re-running targets when executing tests from the release script. ---------------------------------------------------------------------- Version 1.6.1, 01 Mar 2013 User-visible framework improvements: A number of error messages have been clarified. Stub file now supports type annotations in front and after method type variable declarations. You may now specify custom paths to javac.jar and jdk7.jar on the command line for non-standard installations. Internal framework improvements: Add shouldBeApplied method to avoid unnecessary scans in DefaultApplier and avoid annotating void types. Add createQualifierDefaults and createQualifierPolymorphism factory methods. Maven plugin: Put Checker Framework jars at the beginning of classpath. Added option to compile code in order to support checking for multi-module projects. The plugin no longer copies the various Checker Framework maven artifacts to one location but instead takes advantage of the new custom path options for javac.jar and jdk7.jar. The maven plugin no longer attempts to resolve jdk6.jar Eclipse plugin: Put Checker Framework jars at the beginning of classpath. All files selected from a single project can now be checked. The previous behavior only checked the entire project or one file depending on the type of the first file selected. Documentation: Fixed broken links and incomplete URLs in the Checker Framework Manual. Update FAQ to discuss that some other tools incorrectly interpret array declarations. Bug fixes ---------------------------------------------------------------------- Version 1.6.0, 1 Feb 2013 User-visible framework improvements: It is possible to use enum constants in stub files without requiring the fully qualified name, as was previously necessary. Support build on a stock Java 8 OpenJDK. Adapt to underlying jsr308-langtools changes. The most visible change is syntax for fully-qualified types, from @A java.lang.Object to java.lang.@A Object. JDK 7 is now required. The Checker Framework does not build or run on JDK 6. Documentation: A new tutorial is available at https://checkerframework.org/tutorial/ ---------------------------------------------------------------------- Version 1.5.0, 14 Jan 2013 User-visible framework improvements: To invoke the Checker Framework, call the main method of class CheckerMain, which is a drop-in replacement for javac. This replaces all previous techniques for invoking the Checker Framework. Users should no longer provide any Checker Framework jars on the classpath or bootclasspath. jsr308-all.jar has been removed. The Checker Framework now works with both JDK 6 and JDK 7, without need for user customization. The Checker Framework determines the appropriate annotated JDK to use. All jar files now reside in checker-framework/checkers/binary/. Maven plugin: Individual pom files (and artifacts in the Maven repository) for all Checker Framework jar files. Avoid too-long command lines on Windows. See the Maven section of the manual for more details. Eclipse plugin: Avoid too-long command lines on Windows. Other bug fixes and interface improvements. Other framework improvements: New -Adetailedmsgtext command-line option, intended for use by IDE plugins. ---------------------------------------------------------------------- Version 1.4.4, 1 Dec 2012 Internal framework improvements: Add shutdown hook mechanism and use it for -AresourceStats resource statistics flag. Add -AstubWarnIfNotFound and -AstubDebug options to improve warnings and debug information from the stub file parsing. Ignore case when comparing error suppression keys. Support the bottom type as subtype of any wildcard type. Tool Integration Changes The Maven plugin id has been changed to reflect standard Maven naming conventions. Eclipse and Maven plugin version numbers will now track the Checker Framework version numbers. Bug fixes. ---------------------------------------------------------------------- Version 1.4.3, 1 Nov 2012 Clarify license: The Checker Framework is licensed under the GPL2. More permissive licenses apply to annotations, tool plugins (Maven, Eclipse), external libraries included with the Checker Framework, and examples in the Checker Framework Manual. Replaced all third-party annotations by cleanroom implementations, to avoid any potential problems or confusion with licensing. Aliased annotations: Clarified that there is no need to rewrite your program. The Checker Framework recognizes dozens of annotations used by other tools. Improved documentation of Units Checker and Gradle Integration. Improved developer documentation of Eclipse and Maven plugins. Bug fixes. ---------------------------------------------------------------------- Version 1.4.2, 16 Oct 2012 External tool support: Eclipse plug-in now works properly, due to many fixes Regex Checker: New CheckedPatternSyntaxException added to RegexUtil Support new foreign annotations: org.eclipse.jdt.annotation.Nullable org.eclipse.jdt.annotation.NonNull New FAQ: "What is a receiver?" Make annotations use 1-based numbering for formal parameters: Previously, due to a bug the annotations used 0-based numbering. This change means that you need to rewrite annotations in the following ways: @KeyFor("#3") => @KeyFor("#4") @AssertNonNullIfTrue("#0") => @AssertNonNullIfTrue("#1") @AssertNonNullIfTrue({"#0", "#1"}) => @AssertNonNullIfTrue({"#1", "#2"}) @AssertNonNullAfter("get(#2)") => @AssertNonNullAfter("get(#3)") This command: find . -type f -print | xargs perl -pi -e 's/("#)([0-9])(")/$1.($2+1).$3/eg' handles the first two cases, which account for most uses. You would need to handle any annotations like the last two cases in a different way, such as by running grep -r -n -E '\("[^"]+#[0-9][^A-Za-z]|\("#[0-9][^"]' . and making manual changes to the matching lines. (It is possible to provide a command that handles all cases, but it would be more likely to make undesired changes.) Whenever making automated changes, it is wise to save a copy of your codebase, then compare it to the modified version so you can undo any undesired changes. Also, avoid running the automated command over version control files such as your .hg, .git, .svn, or CVS directory. ---------------------------------------------------------------------- Version 1.4.1, 29 Sep 2012 User-visible framework improvements: Support stub files contained in .jar files. Support aliasing for declaration annotations. Updated the Maven plugin. Code refactoring: Make AnnotationUtils and AnnotatedTypes into stateless utility classes. Instead, provide the necessary parameters for particular methods. Make class AnnotationBuilder independent of AnnotationUtils. Remove the ProcessingEnvironment from AnnotatedTypeMirror, which was hardly used and can be replaced easily. Used more consistent naming for a few more fields. Moved AnnotatedTypes from package checkers.types to checkers.utils. this required making a few methods in AnnotatedTypeFactory public, which might require changes in downstream code. Internal framework improvements: Fixed Issues 136, 139, 142, 156. Bug fixes and documentation improvements. ---------------------------------------------------------------------- Version 1.4.0, 11 Sep 2012 User-visible framework improvements: Defaulting: @DefaultQualifier annotations now use a Class instead of a String, preventing simple typo errors. @DefaultLocation extended with more constants. TreeAnnotator propagates the least-upper-bound of the operands of binary/compound operations, instead of taking the default qualifier. Stub files now ignore the return type, allowing for files automatically generated from other formats. Type factories and type hierarchies: Simplify AnnotatedTypeFactory constructors. Add a GeneralAnnotatedTypeFactory that supports multiple type systems. Improvements to QualifierHierarchy construction. Type-checking improvements: Propagate annotations from the sub-expression of a cast to its result. Better handling of assignment context and improved inference of array creation expressions. Optional stricter checking of casts to array and generic types using the new -Alint=cast:strict flag. This will become the default in the future. Code reorganization: SourceChecker.initChecker no longer has a ProcessingEnvironment parameter. The environment can now be accessed using the standard processingEnv field (instead of the previous env field). Classes com.sun.source.util.AbstractTypeProcessor and checkers.util.AggregateChecker are now in package checkers.source. Move isAssignable from the BaseTypeChecker to the BaseTypeVisitor; now the Checker only consists of factories and logic is contained in the Visitor. Warning and error messages: Issue a warning if an unsupported -Alint option is provided. Improved error messages. Maven plugin now works. Nullness Checker: Only allow creation of (implicitly) non-null objects. Optionally forbid creation of arrays with @NonNull component type, when flag -Alint=arrays:forbidnonnullcomponents is supplied. This will become the default in the future. Internal framework improvements: Enable assertion checking. Improve handling of annotated type variables. Assignment context is now a type, not a tree. Fix all compiler warnings. ---------------------------------------------------------------------- Version 1.3.1, 21 Jul 2012 Installation: Clarify installation instructions for Windows. Remove javac.bat, which worked for running distributed checkers but not for creating new checkers. User-visible framework improvements: Implement @PolyAll qualifier to vary over multiple type systems. The Checker Framework is unsound due to Java's covariant array subtyping. You can enable invariant array subtyping (for qualifiers only, not for base Java types) with the command-line option -Alint=arrays:invariant. This will become the default in the future. Internal framework improvements: Improve defaulting for multiple qualifier hierarchies. Big refactoring of how qualifier hierarchies are built up. Improvements to error handling output for unexpected exceptions. Bug fixes and documentation improvements. ---------------------------------------------------------------------- Version 1.3.0, 3 Jul 2012 Annotation syntax changes, as mandated by the latest Type Annotations (JSR 308) specification. The most important ones are: - New receiver syntax, using "this" as a formal parameter name: ReturnType methodname(@ReceiverAnnotation MyClass this, ...) { ... } - Changed @Target default to be the Java 1.5 values - UW extension: in addition to annotations in comments, support special /*>>> */ comments to hide multiple tokens. This is useful for the new receiver syntax and for import statements. Framework improvements: Adapt to annotation storage changes in jsr308-langtools 1.3.0. Move type validation methods from the BaseTypeChecker to BaseTypeVisitor. ---------------------------------------------------------------------- Version 1.2.7, 14 May 2012 Regex Checker: Add basic support for the concatenation of two non-regular expressions that produce a valid regular expression. Support "isRegex" in flow inference. Framework improvements: New @StubFiles annotation declaratively adds stub files to a checker. Internal bug fixes: Respect skipDefs and skipUses in NullnessFlow. Support package annotations in stub files. Better support for enums in annotation attributes. Cleanups to how implicit receivers are determined. ---------------------------------------------------------------------- Version 1.2.6, 18 Mar 2012 Nullness Checker: Correctly handle unboxing in more contexts (if, switch (Issue 129), while loops, ...) Regex Checker: Add capturing groups parameter to Regex qualifier. Count groups in String literals and String concatenation. Verify group number to method calls that take a capturing group number. Update RegexUtil methods to take optional groups parameter. Modify regex qualifier hierarchy to support groups parameter. Add special case for Pattern.compile when called with Pattern.LITERAL flag. Internal bug fixes: Improve flow's support of annotations with parameters. Fix generics corner cases (Issues 131, 132, 133, 135). Support type annotations in annotations and type-check annotations. Improve reflective look-up of visitors and factories. Small cleanups. ---------------------------------------------------------------------- Version 1.2.5.1, 06 Feb 2012 Nullness Checker: Correct the annotations on ThreadLocal and InheritableThreadLocal. Internal bug fixes: Expand release tests. Compile release with JDK 6 to work on both JDK 6 and JDK 7. ---------------------------------------------------------------------- Version 1.2.5, 3 Feb 2012 Don't put classpath on the bootclasspath when invoking javac. This prevents problems if, for example, android.jar is on the classpath. New -jsr308_imports ... and -Djsr308.imports=... command-line options, for specifying implicit imports from the command line. This is needed by Maven. New -Aignorejdkastub option makes the checker not load the jdk.astub file. Files from the "stubs" option are still loaded. Regex Checker: Support concatenation of PolyRegex strings. Improve examples of use of RegexUtil methods. Signature Checker: Add new @ClassGetName annotation, for a 4th string representation of a class that is used by the JDK. Add supporting annotations to make the type hierarchy a complete lattice. Add PolySignature annotation. Internal bug fixes: Improve method type argument inference. Handle type variables whose upper bound is a type variable. Fix bug in least upper bound computation for anonymous classes. Improve handling of annotations inherited from superclasses. Fix design problem with Nullness Checker and primitive types. Ensure that overriding methods respect pre- and postconditions. Correctly resolve references to an enclosing this. Improve handling of Java source that contains compilation errors. ---------------------------------------------------------------------- Version 1.2.4, 15 Dec 2011 All checkers: - @Target(TYPE_USE) meta-annotation is properly handled. Nullness Checker: - Do not allow nullness annotations on primitive types. - Improvements to rawness (initialization) checks. - Special-case known keys for System.getProperty. - The -Alint=uninitialized command-line option now defaults to off, and applies only to initialization of primitive and @Nullable fields. It is not possible to disable, from the command line, the check that all @NonNull fields are initialized. Such warnings must be suppressed explicitly, for example by using @SuppressWarnings. Regex Checker: - Improved RegexUtil class. Manual: - Add FAQ item "Is the Checker Framework an official part of Java?" - Trim down README.txt; users should read the manual instead. - Improvements throughout, especially to Nullness and Regex Checker sections. Implementation details: - Add a new @InvisibleQualifier meta-annotation for type qualifiers. Instead of special-casing @Unqualified in the AnnotatedTypeMirror it now looks for this meta-annotation. This also allows type systems to hide type qualifiers it doesn't want visible, which we now use in the Nullness Checker to hide the @Primitive annotation. - Nullness Checker: Introduce a new internal qualifier @Primitive that is used for primitive types. - Be stricter about qualifiers being present on all types. If you get errors about missing qualifiers, check your defaulting rules. This helped in fixing small bugs in corner cases of the type hierarchy and type factory. - Unify decoding type annotations from trees and elements. - Improve handling of annotations on type variables and upper bounds. - Support checkers that use multiple, disjoint qualifier hierarchies. - Many bug fixes. ---------------------------------------------------------------------- Version 1.2.3, 1 Nov 2011 Regex Checker: - Add @PolyRegex polymorphic annotation - Add more stub library annotations Implementation details: - Do not use "null" for unqualified types. Explicitly use @Unqualified and be strict about correct usage. If this causes trouble for you, check your @ImplicitFor and @DefaultQualifierInHierarchy meta-annotations and ensure correct defaulting in your AnnotatedTypeFactory. Bug fixes: - Correctly handle f-bounded polymorphism. AnnotatedTypeMirror now has methods to query the "effective" annotations on a type, which handles type variable and wildcard bounds correctly. Also, terminate recursions by not doing lazy-initialization of bounds during defaulting. - Many other small bug fixes and documentation updates. ---------------------------------------------------------------------- Version 1.2.2, 1 Oct 2011 Be less restrictive about when to start type processing when errors already exist. Add -AskipDefs command-line option to not type-check some class definitions. Documentation improvements. ---------------------------------------------------------------------- Version 1.2.1, 20 Sep 2011 Fix issues 109, 110, 111 and various other cleanups. Improvements to the release process. Documentation improvements. ---------------------------------------------------------------------- Version 1.2.0.1, 4 Sep 2011 New version number to stay in sync with JSR 308 compiler bugfix. No significant changes. ---------------------------------------------------------------------- Version 1.2.0, 2 Sep 2011 Updated to JDK 8. Use -source 8 (the new default) for type annotations. Documentation improvements Bug fixes all over Nullness Checker: - Correct the upper bounds of all Collection subtypes ---------------------------------------------------------------------- Version 1.1.5, 22 Jul 2011 Units Checker: Instead of conversion routines, provide unit constants, with which to multiply unqualified values. This is easier to type and the multiplication gets optimized away by the compiler. Fenum Checker: Ensure that the switch statement expression is a supertype of all the case expressions. Implementation details: - Parse declaration annotations in stub files - Output error messages instead of raising exceptions. This change required us to introduce method "initChecker" in class SourceChecker, which should be used instead of "init". This allows us to handle the calls to initChecker within the framework. Use method "errorAbort" to output an error message and abort processing. ---------------------------------------------------------------------- Version 1.1.4, 8 Jul 2011 Units Checker (new): Ensures operations are performed on variables of correct units of measurement (e.g., miles vs. kilometers vs. kilograms). Changed -AskipClasses command-line option to -AskipUses Implementation details: - Improve support for type qualifiers with enum attributes ---------------------------------------------------------------------- Version 1.1.3, 17 Jun 2011 Interning: - Add @UsesObjectEquals annotation Manual: - Signature Checker is now documented - Fenum Checker documentation improved - Small improvements to other sections Implementation details: - Updates to the web-site build process - The BaseTypeVisitor used to provide the same two type parameters as class SourceVisitor. However, all subtypes of BaseTypeVisitor were instantiated as . We decided to directly instantiate the SourceVisitor as and removed this complexity. Instead, the BaseTypeVisitor is now parameterized by the subtype of BaseTypeChecker that should be used. This gives a more concrete type to field "checker" and is similar to BasicAnnotatedTypeFactory. - Added method AnnotatedTypeFactory.typeVariablesFromUse to allow type-checkers to adapt the upper bounds of a type variable depending on the type instantiation. - Method type argument inference: Changed AnnotatedTypeFactory.methodFromUse to return a Pair consisting of the method and the inferred or explicit method type arguments. If you override this method, you will need to update your version. See this change set for a simple example: https://github.com/typetools/checker-framework/source/detail?r=8381a213a4 - Testing framework: Support for multiple expected errors using the "//:: A :: B :: C" syntax. Many small updates and fixes. ---------------------------------------------------------------------- Version 1.1.2, 12 Jan 2011 Fake Enum Checker (new): A "fake enumeration" is a set of integers rather than a proper Java enum. They are used in legacy code and for efficiency (e.g., in Android). The Fake Enum Checker gives them the same safety guarantees as a proper Java enum. Property File Checker (new): Ensures that valid keys are used for property files and resource bundles. Also includes a checker that code is properly internationalized and a checker for compiler message keys as used in the Checker Framework. Signature Checker (new): Ensures that different string representations of a Java type (e.g., "package.Outer.Inner" vs. "package.Outer$Inner" vs. "Lpackage/Outer$Inner;") are not misused. Interning Checker enhancements: Issues fewer false positives for code like "a==b || a.equals(b)" Foreign annotations: The Checker Framework supports more non-Checker-Framework annotations. This means that it can check already-annotated code without requiring you to rewrite your annotations. Add as an alias for checkers.interning.quals.Interned: com.sun.istack.Interned Add as aliases for checkers.nullness.quals.NonNull: com.sun.istack.NotNull org.netbeans.api.annotations.common.NonNull Add as aliases for checkers.nullness.quals.Nullable: com.sun.istack.Nullable javax.validation.constraints.NotNull org.netbeans.api.annotations.common.CheckForNull org.netbeans.api.annotations.common.NullAllowed org.netbeans.api.annotations.common.NullUnknown Manual improvements: Improve installation instructions Rewrite section on generics (thanks to Bert Fernandez and David Cok) Also refactor the generics section into its own chapter Rewrite section on @Unused and @Dependent New manual section: Writing Java expressions as annotation arguments Better explanation of warning suppression JSR 308 is planned for Java 8, not Java 7 Stub files: Support nested classes by expressing them at top level in binary form: A$B Improved error reporting when parsing stub files Annotated JDK: New way of generating annotated JDK jdk.jar file no longer appears in repository Warning if you are not using the annotated JDK. Miscellaneous: Warn if -source command-line argument does not support type annotations Many bug fixes There are too many to list, but some notable ones are to local type inference, generics, pre- and post-conditions (e.g., @NonNullOnEntry, @AssertNonNull*), and map keys (@KeyFor). In particular, preconditions and map key annotations are now checked, and if they cannot be verified, an error is raised; previously, they were not verified, just unsoundly trusted. ---------------------------------------------------------------------- Version 1.1.1, 18 Sep 2010 Eclipse support: Removed the obsolete Eclipse plug-in from repository. The new one uses a different repository (http://code.google.com/a/eclipselabs.org/p/checker-plugin/) but a user obtains it from the same URL as before: https://checkerframework.org/eclipse/ Property Key Checker: The property key checker allows multiple resource bundles and the simultaneous use of both resource bundles and property files. Javari Checker: Added Javari stub classes for more JDK classes. Distribution: Changed directory structure (top level is "checker-framework"; "checkers" is a under that) for consistency with version control repository. Many documentation improvements and minor bugfixes. ---------------------------------------------------------------------- Version 1.1.0b, 16 Jun 2010 Fixed a bug related to running binary release in JDK 6 ---------------------------------------------------------------------- Version 1.1.0, 13 Jun 2010 Checkers Introduced a new simple mechanism for running a checker Added one annotated JDK for all checkers Nullness Checker Fixed bugs related to map.get() and KeyFor annotation Fixed bugs related to AssertNonNull* and parameters Minor updates to the annotated JDK, especially to java.io.File Manual Updated installation instructions Clarified section regarding fields and type inference ---------------------------------------------------------------------- Version 1.0.9, 25 May 2010 Nullness Checker: Improved Javadocs and manual documentation Added two new annotations: AssertNonNullAfter, KeyFor Fixed a bug related to AssertNonNullIfFalse and assert statements Renamed NonNullVariable to NonNullOnEntry Checkers: Interning: Skipping equality check, if either operands should be skipped Fixed a bug related to annotations targeting array fields found in classfile Fixed a bug related to method invocation generic type inference in static methods Manual Added a section on nullness method annotations Revised the Nullness Checker section Updated Ant usage instructions ---------------------------------------------------------------------- Version 1.0.8, 15 May 2010 Checkers Changed behavior of flow type refinement when annotation is explicit Handle array initializer trees (without explicit type) Handle the case of Vector.copyInto Include javax classes in the distributed jdk jar files Interning Checker Handle interning inference of string concatenation Add 20+ @Interned annotations to the JDK Add an option, checkclass, to validate the interning of specific classes only Bug fixes Fix a bug related to array implicit types Lock Checker: Treat null as a bottom type Manual Added a new section about Flow inference and fields ---------------------------------------------------------------------- Version 1.0.7, 12 Apr 2010 Checkers Distributed a Maven repository Updated stub parser project to latest version (javaparser 1.0.8) Fixed bugs related to iterable wildcards and type parameter types ---------------------------------------------------------------------- Version 1.0.6, 24 Feb 2009 Nullness Checker Added support for new annotations: Pure - indicates that the method, given the same parameters, return the same values AssertNonNullIfFalse - indicates that a field is NonNull if the method returns false Renamed AssertNonNull to AssertParametersNonNull Updated the annotated jdk Javari Checker Fixed many bugs: handle implicit dereferencing of this (e.g. `field` in place of `this.field`) apply default annotations to method parameters ---------------------------------------------------------------------- Version 1.0.5, 12 Jan 2009 Checkers Added support for annotated jdk jars Improved readability of some failure messages Added AssertNonNullIfTrue support for method parameter references Fixed a bug related to LazyNonNull and array fields Fixed a bug related to inference and compound assignments (e.g. +=) nullness: permit the type of @NonNull Void Manual Updated annotating-libraries chapter regarding annotated jdk ---------------------------------------------------------------------- Version 1.0.4, 19 Dec 2009 Bug Fixes wildcards not recognized as subtypes of type variables e.g. '? extends A' and 'A' PolyNull methods not accepting null literal value arguments spurious unexpected Raw warnings Manual Clarified FAQ item regarding why List's type parameter is "extends @NonNull Object" ---------------------------------------------------------------------- Version 1.0.3, 5 Dec 2009 Checkers New location UPPER_BOUND for DefaultQualifier permits setting the default for upper bounds, such as Object in "? extends Object". @DefaultQualifier accepts simple names, like @DefaultQualifier("Nullable"), rather than requiring @DefaultQualifier("checkers.nullness.quals.Nullable"). Local variable type inference has improved support for array accesses. The repository contains Eclipse project and launch configuration files. This is helpful too people who want to build a checker, not to people who merely want to run a checker. Many bug fixes, including: handling wildcard subtyping rules stub files and vararg methods being ignored nullness and spurious rawness errors uses of array clone method (e.g. String[].clone()) multibound type parameters (e.g. ) Manual Documented the behavior of annotations on type parameter declarations. New FAQ item: How to collect warnings from multiple files Why a qualifier shouldn't apply to both types and declarations ---------------------------------------------------------------------- Version 1.0.2, 16 Nov 2009 Checkers Renamed Regex Checker's @ValidRegex annotation to @Regex Improved Collection.toArray() heuristics to be more sound Bug fixes Fixed the annotated JDK to match OpenJDK 6 - Added missing methods and corrected class hierarchy Fixed a crash related to intersection types ---------------------------------------------------------------------- Version 1.0.1, 1 Nov 2009 Checkers Added new checkers: RegEx checker to detect invalid regular expression use Internationalization (I18n) checker to detect internationalization errors Functionality Added more performance optimizations nullness: Added support for netbeans nullness annotations nullness: better semantics for redundant nullness tests related to redundant tests in assertions lock: Added support for JCIP annotation in the Lock Checker tainting: Added support for polymorphism Lock Checker supports the JCIP GuardedBy annotation Bug fixes Fixed a crashing bug related to interaction between generic types and wildcards Fixed a bug in stub file parser related to vararg annotations Fixed few bugs in skeleton file generators Manual Tweak installation instructions Reference Units Checker Added new sections for new checkers RegEx checker (S 10) Internationalization Checker (S 11) ---------------------------------------------------------------------- Version 1.0.0, 30 Sep 2009 Functionality Added Linear Checker to restrict aliasing Bug fixes Fixed flow erros related to loop controls and break/continue Manual Adopt new term, "Declaration Annotation" instead of non-type annotations Added new sections: Linear Checker (S 9) Inexpressible types (S 14.3) How to get started annotating legacy code (S 2.4.4) Expanded Tainting Checker section ---------------------------------------------------------------------- Version 0.9.9, 4 Sep 2009 Functionality Added more optional lint checks (cast:unsafe, all) Nullness Checker supports @SuppressWarnings("nullness:generic.argument"), for suppressing warnings related to misuse of generic type arguments. This was already supported and documented, but had not been mentioned in the changelog. Bug fixes Fixed many bugs related to Stub files causing parser to ignore bodiless constructors annotated arrays annotations type parameter and wildcard bounds annotations Manual Rewrote 'javac implementation survival guide' (S 13.9) Restructured 'Using a checker' (S 2) Added 'Integration with external tools' (S 14) Added new questions to the FAQ (S 15) ---------------------------------------------------------------------- Version 0.9.8, 21 Aug 2009 Functionality Added a Tainting Checker Added support for conditional nonnull checking Added optional check for redundant nullness tests Updated stub parser to latest libraries Bug fixes Fixed a bug related to int[] treated as Object when passed to vararg T... Fixed a crash related to intersection types Fixed a bug related to -AskipClasses not being honored Fixed a bug related to flow Manual Added new sections 8 Tainting Checker 3.2.3 Conditional nullness ---------------------------------------------------------------------- Version 0.9.7, 12 Aug 2009 Functionality Changed swNonNull to castNonNull nullness: Improved flow to infer nullness based on method invocations locking: Permitted @Holding to appear on constructors Bug fixes Fixed a bug related to typevar and wildcard extends clauses ---------------------------------------------------------------------- Version 0.9.6, 29 Jul 2009 Functionality Changed 'jsr308.skipClasses' property with '-AskipClasses' option Locking checker - Add subtype checking for Holding - Treat constructors as synchronized methods Bug fixes Added some missing nullness annotations in the jdk Fixed some bugs related to reading stub files Manual Added a new section 2.10 Tips about writing annotations Updated sections of 2.6 Unused fields and dependent types 3.1.1 Rawness annotation hierarchy ---------------------------------------------------------------------- Version 0.9.5, 13 Jul 2009 Functionality Added support for Findbugs, JSR305, and IntelliJ nullness annotations Added an Aggregate Checker base-class Added support for a form of field access control Bug fixes Added check for arguments in super() calls in constructors Manual Added new sections: Fields access control Other tools for nullness checking Bundling multiple checkers ---------------------------------------------------------------------- Version 0.9.4, 30 Jun 2009 Functionality Added Lock Checker Bug fixes Handle more patterns for determining Map.get() return type Manual Documentations Improved installation instructions Added the following sections 2.6 Dependent types 3.1 subsection for LazyNonNull 10.9 When to use (and not to use) type qualifiers ---------------------------------------------------------------------- Version 0.9.3, 23 Jun 2009 Functionality Added support DefaultQualifier on packages Added support for Dependent qualifier types see checkers.quals.Dependent Added an option to treat checker errors as warnings Improved flow handling of boolean logic Manual Documentations Improved installation instructions Improved discussion of effective and implicit qualifiers and defaults Added a discussion about the need for bottom qualifiers Added sections for how-to . suppress Basic Checker warnings . troubleshoot skeleton files ---------------------------------------------------------------------- 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 { ... } 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 https://checkerframework.org/api/ . ---------------------------------------------------------------------- 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 Checker 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 Checker 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 Checker Framework API Added support for conditional expression Added checks for type validity and assignability Added support for per-checker 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 autoboxing/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 Checker 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 Checker 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 Checker 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 Checker 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 Checker Framework API. Fixed a bug in which "new" expressions had an incorrect type. NonNull Checker Adopted the new Checker 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. Checker 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 Checker 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 type-checker 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 Checker Framework 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 ch examples Checker Framework build file now only attempts to compile .java files ---------------------------------------------------------------------- Version 0.1.0, 1 May 2007 Initial release.