All Classes and Interfaces
Class
Description
Ampere.
Units of acceleration.
Annotation to override the UI effect on a class, and make a field or method safe for non-UI code
to use.
Units of measure for angles.
Indicates that this class has been annotated for the given type system.
Units of areas.
An annotation indicating the length of an array or a string.
An expression with this type evaluates to an array or a string whose length is in the given
range.
An identifier or primitive type, followed by any number of array square brackets.
Indicates that if the method returns a non-null value, then the value expressions are also
non-null.
Basic alpha compositing rules for combining source and destination colors to achieve blending and
transparency effects with graphics and images (see
AlphaComposite for more
details).Color space tags to identify the specific color space of a Color object or, via a ColorModel
object, of an Image, a BufferedImage, or a GraphicsDevice (see
ColorSpace
for more details).AwtCursorType.
Line alignments in a flow layout (see
FlowLayout for more details).Represents a binary name as defined in the Java Language
Specification, section 13.1.
Represents a primitive type name or a
binary name.An annotation indicating the possible values for a bool type.
A special annotation intended solely for representing the bottom type in the qualifier hierarchy.
The bottom type for the Returns Receiver Checker's type system.
The bottom type in the Constant Value type system.
Degree Centigrade (Celsius).
A deprecated variant of
CalledMethods.If an expression has type
@CalledMethods({"m1", "m2"}), then methods m1 and
m2 have definitely been called on its value.The bottom type for the Called Methods type system.
This annotation represents a predicate on
@CalledMethods annotations.Canonical names have the same syntactic form as
fully-qualified names.This is a string that is a valid canonical name and a valid binary name.
Either a
CanonicalName or the empty string.This is a string that is a valid canonical name and a valid
binary name or primitive type.
Candela (unit of luminance).
This annotation is for comments related to the Checker Framework.
This represents a
Class<T> object whose run-time value is equal to or a subtype of one of
the arguments.The type representation used by the
Class.getName(), Class.forName(String), and
Class.forName(String, boolean, ClassLoader) methods.The format produced by the
Class.getSimpleName() method.This represents a
Class<T> object where the set of possible values
of T is known at compile time.The bottom type in the ClassVal type system.
Method declaration annotation that indicates a method has a specification like
compareTo() or compare().A string that is definitely a compiler message key.
The bottom type in the Compiler Message Key type system.
A meta-annotation that indicates that an annotation E is a conditional postcondition annotation,
i.e., E is a type-specialized version of
EnsuresQualifierIf or EnsuresQualifierIf.List.Elements of this enumeration are used in a
Format annotation to indicate the valid
types that may be passed as a format parameter.A marker annotation, written on a class declaration, that signifies that one or more of the
class's type parameters can be treated covariantly.
Indicates that the method resets the expression's must-call type to its declared type.
A wrapper annotation that makes the
CreatesMustCallFor annotation repeatable.Electric current.
A meta-annotation applied to the declaration of a type qualifier.
Applied to a declaration of a package, type, method, variable, etc., specifies that the given
annotation should be the default.
A wrapper annotation that makes the
DefaultQualifier annotation repeatable.Declaration annotation applied to type declarations to specify the qualifier to be added to
unannotated uses of the type.
Indicates that the annotated qualifier is the default qualifier in the qualifier hierarchy: it
applies if the programmer writes no explicit qualifier and no other default has been specified
for the location.
Degrees.
A method is called deterministic if it returns the same value (according to
==)
every time it is called with the same parameters and in the same environment.This is a string that is a valid fully qualified name and a valid
binary name.
This is a string that is a valid fully qualified name and a valid
binary name or
primitive type.
An annotation indicating the possible values for a double or float type.
Indicates that the method, if it terminates successfully, always invokes the given methods on the
given expressions.
Indicates that the method, if it terminates with the given result, invokes the given methods on
the given expressions.
A wrapper annotation that makes the
EnsuresCalledMethodsIf annotation repeatable.Indicates that the method, if it terminates successfully, always invokes the given methods on all
of the arguments passed in the varargs position.
A method postcondition annotation indicates which fields the method definitely initializes.
A wrapper annotation that makes the
EnsuresInitializedFields annotation repeatable.Indicates that the value expressions evaluate to a value that is a key in all the given maps, if
the method terminates successfully.
A wrapper annotation that makes the
EnsuresKeyFor annotation repeatable.Indicates that the given expressions evaluate to a value that is a key in all the given maps, if
the method returns the given result (either true or false).
A wrapper annotation that makes the
EnsuresKeyForIf annotation repeatable.Indicates that the given expressions are held if the method terminates successfully.
A wrapper annotation that makes the
EnsuresLockHeld annotation repeatable.Indicates that the given expressions are held if the method terminates successfully and returns
the given result (either true or false).
A wrapper annotation that makes the
EnsuresLockHeldIf annotation repeatable.Indicates that the value expressions evaluate to an integer whose value is less than the lengths
of all the given sequences, if the method terminates successfully.
A wrapper annotation that makes the
EnsuresLTLengthOf annotation repeatable.Indicates that the given expressions evaluate to an integer whose value is less than the lengths
of all the given sequences, if the method returns the given result (either true or false).
A wrapper annotation that makes the
EnsuresLTLengthOfIf annotation repeatable.Indicates that the value of the given expression is a sequence containing at least the given
number of elements, if the method returns the given result (either true or false).
A wrapper annotation that makes the
EnsuresMinLenIf annotation repeatable.Indicates that the value expressions are non-null just after a method call, if the method
terminates successfully.
A wrapper annotation that makes the
EnsuresNonNull annotation repeatable.Indicates that the given expressions are non-null, if the method returns the given result (either
true or false).
* A wrapper annotation that makes the
EnsuresNonNullIf annotation repeatable.A postcondition annotation to indicate that a method ensures that certain expressions have a
certain type qualifier once the method has successfully terminated.
A wrapper annotation that makes the
EnsuresQualifier annotation repeatable.A conditional postcondition annotation to indicate that a method ensures that certain expressions
have a certain qualifier once the method has terminated, and if the result is as indicated by
result.A wrapper annotation that makes the
EnsuresQualifierIf annotation repeatable.An annotation indicating the possible values for an enum type.
Method declaration annotation that indicates a method has a specification like
equals().The bottom type in the initialization type system.
A generic fake enumeration qualifier that is parameterized by a name.
The bottom type in the Fenum type system.
The top of the fake enumeration type hierarchy.
An unqualified type.
Represents a field descriptor (JVM type format) as defined in the Java Virtual
Machine Specification, section 4.3.2.
Represents a field descriptor (JVM type format) for a primitive as defined in the Java Virtual
Machine Specification, section 4.3.2.
Represents a
field descriptor for a primitive or for an array whose base
type is primitive or in the unnamed package.Specifies that a field's type, in the class on which this annotation is written, is a subtype of
its declared type.
This formal parameter annotation indicates that the method searches for the given value, using
reference equality (
==).Units of force.
This annotation, attached to a String type, indicates that the String may be passed to
Formatter.format and similar methods.The bottom type in the Format String type system.
If this annotation is attached to a
Formatter.format-like method, then the first parameter of type String is treated as a format
string for the following arguments.Annotation for methods like
Class.forName.An extension of binary name format to represent primitives and arrays.
If a method is annotated with this declaration annotation, then its signature is not written in a
stub file and the method is not declared in source.
If a method is annotated with this declaration annotation, then its signature was read from a
stub file.
A sequence of dot-separated identifiers, followed by any number of array square brackets.
Gram.
Annotation for methods like
Object.getClassName.Annotation for methods like
Class.getConstructor, whose signature is: @MethodVal(classname=c, methodname="<init>", params=p) Constructor<T>
method(Class<c> this, Object... params)Annotation for methods like
Class.getMethod and Class.getDeclaredMethod, whose
signature is: {@link MethodVal}(classname=c, methodname=m, params=p) Method getMyMethod(Class<c> this,
String m, Object... params)The annotated expression evaluates to an integer greater than or equal to -1.
Indicates that a thread may dereference the value referred to by the annotated variable only if
the thread holds all the given lock expressions.
The bottom type in the GuardedBy type system.
It is unknown what locks guard the value referred to by the annotated variable.
If a variable
x has type @GuardSatisfied, then all lock expressions for
x's value are held.Hour.
This is a declaration annotation that applies to type declarations and packages.
The annotated sequence contains a subsequence that is equal to the value of some other
expression.
Indicates a method precondition: the specified expressions must be held when the annotated method
is invoked.
This annotation is used internally to annotate
(and will potentially
be used to annotate more such functions in the future).
invalid reference
org.checkerframework.checker.i18nformatter.util.I18nFormatUtil#hasFormatElements of this enumeration are used in a
I18nFormat annotation to indicate the valid
types that may be passed as a format parameter.This annotation, attached to a String type, indicates that the String may be passed to
MessageFormat.format.The bottom type in the Internationalization Format String type system.
This annotation indicates that when a string of the annotated type is passed as the first
argument to
MessageFormat.format(String, Object...), then the expression that
is an argument to the annotation can be passed as the remaining arguments, in varargs style.This annotation, attached to a
String type, indicates that if the String
is passed to MessageFormat.format(String, Object...), an exception will result.This annotation is used internally to annotate
ResourceBundle.getString(java.lang.String)
indicating the checker to check if the given key exist in the translation file and annotate the
result string with the correct format annotation according to the corresponding key's value.The top qualifier.
This annotation is used internally to annotate
.
invalid reference
org.checkerframework.checker.i18nformatter.util.I18nFormatUtil#isFormatAn identifier.
An identifier or a primitive type.
This annotation can be used two ways:
An integer that can be used to index any of the given sequences.
An integer that, for each of the given sequences, is either a valid index or is equal to the
sequence's length.
An integer that is either -1 or is a valid index for each of the given sequences.
This annotation is an alias for
MustCall that applies to the type on which it is written
and all of its subtypes.A meta-annotation that specifies if a declaration annotation should be inherited.
This type qualifier belongs to the freedom-before-commitment initialization tracking type-system.
Indicates which fields have definitely been initialized.
The bottom type qualifier for the Initialized Fields type system.
The syntax for binary names that appears in a class file, as defined in the JVM
Specification, section 4.2.
Indicates that a variable has been interned, i.e., that the variable refers to the canonical
representation of an object.
Indicates that no other value is
equals() to the given value.Method declaration annotation used to indicate that this method may be invoked on an uninterned
object and that it returns an interned object.
An expression with this type evaluates to an integral value (byte, short, char, int, or long) in
the given range.
An expression with this type is exactly the same as an
IntRange annotation whose
from field is -1 and whose to field is Integer.MAX_VALUE.An expression with this type is exactly the same as an
IntRange annotation whose
from field is 0 and whose to field is Integer.MAX_VALUE.An expression with this type is exactly the same as an
IntRange annotation whose
from field is 1 and whose to field is Integer.MAX_VALUE.An annotation indicating the possible values for a byte, short, char, int, or long type.
This annotation, attached to a
String type, indicates that the string is
not a legal format string.A meta-annotation indicating that an annotation is a type qualifier that should not be visible in
output.
Annotation for methods like
Method.invoke, whose signature is: Object method({@link MethodVal}(classname=c, methodname=m, params=p) Method this, Object
obj, Object... args)An annotation to use on an element of a dependent type qualifier to specify which elements of the
annotation should be interpreted as Java expressions.
Kelvin (unit of temperature).
Indicates that the value assigned to the annotated variable is a key for at least the given
map(s).
The bottom type in the Map Key type system.
Kilogram.
Kilometer.
Square kilometer.
Cubic kilometer.
Kilometer per hour.
Kilonewton.
This annotation is used on a formal parameter to indicate that the parameter may be returned, but
it is not otherwise leaked.
Units of length.
An integer that, for each of the given sequences, is equal to the sequence's length.
An annotation indicating the relationship between values with a byte, short, char, int, or long
type.
The bottom type in the LessThan type system.
The top qualifier for the LessThan type hierarchy.
Specifies kinds of literal trees.
Indicates that the
String is a key into a property file or resource bundle containing
Localized Strings.The bottom type in the Internationalization type system.
Indicates that the
String type has been localized and formatted for the target output
locale.Indicates that an expression is used as a lock and the lock is known to be held on the current
thread.
The method neither acquires nor releases locks, nor do any of the methods that it calls.
Indicates that an expression is not known to be
LockHeld.The bottom type of the lower bound type system.
The annotated expression evaluates to value that might be -2 or lower.
The annotated expression evaluates to an integer whose value is less than or equal to the lengths
of all the given sequences.
The annotated expression evaluates to an integer whose value is less than the lengths of all the
given sequences.
The annotated expression evaluates to an integer whose value is at least 2 less than the lengths
of all the given sequences.
Units of luminance.
Meter.
Square meter.
Cubic meter.
Units of mass.
An annotation indicating the possible values for a String type.
An expression with this type might have an alias.
Temporary type qualifier:
The
Optional container may or may not contain a value.The method, or one of the methods it calls, might release locks that were held prior to the
method being called.
Represents a method descriptor (JVM representation of method signature) as defined in the Java Virtual
Machine Specification, section 4.3.3.
This represents a set of
Method or Constructor values.The bottom type in the MethodVal type system.
Minute.
The value of the annotated expression is a sequence containing at least the given number of
elements.
A specialization of
FieldInvariant for specifying the minimum length of an array.MixedUnits is the result of multiplying or dividing units, where no more specific unit is known
from a UnitsRelations implementation.
Millimeter.
Square millimeter.
Cubic millimeter.
Mole (unit of
Substance).Indicates that once the field (or variable) becomes non-null, it never becomes null again.
A meta-annotation that indicates that a qualifier indicates that an expression goes monotonically
from a type qualifier
T to another qualifier S.Meter per second.
Meter per second squared.
An expression of type
@MustCall({"m1", "m2"}) may be obligated to call m1()
and/or m2() before it is deallocated, but it is not obligated to call any other methods.This polymorphic annotation represents an either-or must-call obligation.
The top qualifier in the Must Call type hierarchy.
Newton.
The annotated expression is between
-1 and -a.length - 1, inclusive, for each
sequence a listed in the annotation.Annotation for methods like
Constructor.newInstance, whose signature is: T method(MethodVal(classname=c, methodname="<init>", params=p) Constructor
this, Object... args)A type that represents a newly-constructed object.
Declaration annotation applied to type declarations to specify that the annotation on the type
declaration should not be applied to unannotated uses of the type.
This annotation is used on a formal parameter to indicate that the parameter is not leaked
(stored in a location that could be accessed later) nor returned by the method body.
The annotated expression evaluates to an integer greater than or equal to 0.
If an expression's type is qualified by
@NonNull, then the expression never evaluates to
null.This is a declaration annotation that applies to type declarations.
An annotation speculatively used by Lombok's lombok.config checkerframework = true option.
A declaration annotation for fields that indicates that a client might observe the field storing
values that are
Initialized, UnderInitialization, or UnknownInitialization, regardless of the
initialization type annotation on the field's type.Annotation indicating that ownership should not be transferred to the annotated parameter, field,
or method's call sites, for the purposes of Must Call checking.
Nullable is a type annotation that makes no commitments about whether the value is
null.The bottom type qualifier for the Optional Checker.
Annotation indicating that ownership should be transferred to the annotated element for the
purposes of Must Call checking.
Indicates a String that is not a syntactically valid regular expression.
A polymorphic qualifier for the fake enum type system.
A polymorphic qualifier for the Lower Bound and Upper Bound type systems.
Polymorphic qualifier for the Initialized Fields type system.
A polymorphic qualifier for the Interning type system.
A polymorphic qualifier for the Map Key (@KeyFor) type system.
Syntactic sugar for both @PolyValue and @PolySameLen.
A polymorphic qualifier for the Lower Bound type system.
A meta-annotation that indicates that an annotation is a polymorphic type qualifier.
The polymorphic qualifier for the Must Call type system.
A polymorphic qualifier for the non-null type system.
A polymorphic qualifier for the Optional type system.
A polymorphic qualifier for the Regex type system.
A polymorphic qualifier for the SameLen type system.
A polymorphic qualifier for the Signature type system.
A polymorphic qualifier for the signedness type system.
A polymorphic qualifier for the Tainting type system.
Annotation for the polymorphic-UI effect.
Annotation for the polymorphic effect on methods, or on field accesses.
Annotation for the polymorphic type declaration.
A polymorphic qualifier for the units-of-measure type system implemented by the Units Checker.
A polymorphic qualifier for the Upper Bound type system.
A polymorphic qualifier for the Constant Value Checker.
The annotated expression evaluates to an integer greater than or equal to 1.
A meta-annotation that indicates that an annotation E is a postcondition annotation, i.e., E is a
type-specialized version of
EnsuresQualifier or of EnsuresQualifier.List.A meta-annotation that indicates that an annotation R is a precondition annotation, i.e., R is a
type-specialized version of
RequiresQualifier.SI prefixes.
The
Optional container definitely contains a (non-null) value.A primitive type.
Indicates that the
String type can be used as key in a property file or resource bundle.The bottom type in the PropertyKeyChecker (and associated checkers) qualifier hierarchy.
The type of purity.
An annotation intended solely for representing an unqualified type in the qualifier hierarchy for
the Purity Checker.
An annotation to use on an element of a contract annotation to indicate that the element
specifies the value of an argument of the qualifier.
A meta-annotation that indicates what qualifier should be given to literals.
Radians.
If a type is annotated as
@Regex(n), then the run-time value is a regular expression with
n capturing groups.The bottom type in the Regex type system.
The method maintains a strictly nondecreasing lock held count on the current thread for any locks
that were held prior to the method call.
An annotation on a SourceChecker subclass to specify which Java types are processed by the
checker.
Report all calls of a method that has this annotation, including calls of methods that override
this method.
Report all instantiations of a class/interface that has this annotation, including any subclass.
Report all types that extend/implement a type that has this annotation.
Report all methods that override a method with this annotation.
Report all read or write access to a field with this annotation.
An annotation intended solely for representing an unqualified type in the qualifier hierarchy for
the Report Checker.
Report all uses of a type that has this annotation.
Report all write accesses to a field with this annotation.
Indicates a method precondition: when the method is invoked, the specified expressions must have
had the specified methods called on them.
A wrapper annotation that makes the
RequiresCalledMethods annotation repeatable.Indicates a method precondition: the method expects the specified expressions to be non-null when
the annotated method is invoked.
A wrapper annotation that makes the
RequiresNonNull annotation repeatable.A precondition annotation to indicate that a method requires certain expressions to have a
certain qualifier at the time of the call to the method.
A wrapper annotation that makes the
RequiresQualifier annotation repeatable.Attach this annotation to a method with the following properties:
The first parameter is a format string.
A deprecated variant of
org.checkerframework.common.returnsreceiver.qual.This.A second (1/60 of a minute).
Annotation for the concrete safe effect on methods, or on field accesses.
Class declaration annotation to make methods default to
@AlwaysSafe.An expression whose type has this annotation evaluates to a value that is a sequence, and that
sequence has the same length as the given sequences.
The bottom type in the SameLen type system.
This type represents any variable that isn't known to have the same length as another sequence.
The bottom type in the Search Index type system.
The annotated expression evaluates to an integer whose length is between
-a.length - 1
and a.length - 1, inclusive, for all sequences a listed in the annotation.The top type for the SearchIndex type system.
A method is called side-effect-free if it has no visible side-effects, such as setting a
field of an object that existed before the method was called.
The bottom type in the Signature String type system.
Top qualifier in the type hierarchy.
The value is to be interpreted as signed.
The bottom type in the Signedness type system.
The expression's value is in the signed positive range; that is, its most significant bit is not
set.
The expression is
@SignedPositive, and its value came from widening a value that
is allowed to be interpreted as unsigned.Units of speed.
StaticallyExecutable is a method annotation that indicates that the compiler is allowed to run
the method at compile time, if all of the method's arguments are compile-time constants.
An annotation indicating the possible values for a String type.
An annotation on a SourceChecker subclass to provide additional stub files that should be used in
addition to
jdk.astub.Units of substance, such as mole (@
mol).The bottom type in the Substring Index type system.
The annotated expression evaluates to either -1 or a non-negative integer less than the lengths
of all the given sequences.
The top type for the Substring Index type system.
A meta-annotation to specify all the qualifiers that the given qualifier is an immediate subtype
of.
SwingBoxOrientation.
SwingCompassDirection.
SwingElementOrientation.
SwingHorizontalOrientation.
SwingSplitPaneOrientation.
SwingTextOrientation.
Vertical orientations for the title text of a
TitledBorder.Justifications for the title text of a
TitledBorder.SwingVerticalOrientation.
Metric ton.
Denotes a possibly-tainted value: at run time, the value might be tainted or might be untainted.
NOTE: This meta-annotation is not currently
enforced.
Units of temperature.
TerminatesExecution is a method annotation that indicates that a method terminates the
execution of the program.Write
@This on the return type of a method that always returns its receiver (
this).Units of time.
Specifies kinds of types.
Specifies the locations to which a
DefaultQualifier annotation applies.Annotation for the UI effect.
Annotation for the concrete UI effect on methods, or on field accesses.
Package annotation to make all classes within a package
@UIType.Class declaration annotation to make methods default to
@UI.This type qualifier indicates that an object is (definitely) in the process of being
constructed/initialized.
An expression with this type has no aliases.
The bottom type in the Units type system.
Define the relation between a base unit and the current unit.
Specify the class that knows how to handle the meta-annotated unit when put in relation (plus,
multiply, ...) with another unit.
Represents a Class object whose run-time value is not known at compile time.
A
String that might or might not be a compiler message key.The top qualifier.
This type qualifier indicates how much of an object has been fully initialized.
The top qualifier for the Interning Checker.
Used internally by the type system; should never be written by a programmer.
Indicates that the
String type has an unknown localizable key property.Indicates that the
String type has unknown localization properties.Represents a
Method or Constructor expression whose run-time value is not known at compile time.Indicates that the
String type has an unknown property key property.Represents the top of the Regex qualifier hierarchy.
The value's signedness is not known to the Signedness Checker.
The top type for the Returns Receiver Checker's type system.
UnknownUnits is the top type of the type hierarchy.
UnknownVal is a type annotation indicating that the expression's value is not known at compile
type.
A special annotation intended solely for representing an unqualified type in the qualifier
hierarchy, as an argument to
SubtypeOf.value(), in a type qualifier declaration.The value is to be interpreted as unsigned.
Denotes a reference that is untainted, i.e.
Declares that the field may not be accessed if the receiver is of the specified qualifier type
(or any supertype).
The bottom type in the Upper Bound type system.
A meta-annotation applied to the declaration of a type qualifier.
A literal value.
A variable not known to have a relation to any sequence length.
Class declaration to indicate the class does not override
equals(Object), and therefore
a.equals(b) and a == b behave identically.Units of volume.