framework.src.org.checkerframework.framework.qual.MonotonicQualifier Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of checker Show documentation

The Checker Framework enhances Java’s type system to make it more powerful and useful. This lets software developers detect and prevent errors in their Java programs. The Checker Framework includes compiler plug-ins ("checkers") that find bugs or verify their absence. It also permits you to write your own compiler plug-ins.

There is a newer version: 3.42.0

Show newest version

package org.checkerframework.framework.qual;

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * A meta-annotation that indicates that a qualifier indicates that an
 * expression goes monotonically from a type qualifier {@code T} to another
 * qualifier {@code S}. The annotation {@code S} is called the target
 * of the monotonic qualifier, and has to be indicated by
 * {@link MonotonicQualifier#value()}.
 *
 * 
 * This meta-annotation can be used on the declaration of the monotonic
 * qualifier used for the type-system at hand, and is often called {@code MonoT}
 * if the target is {@code T}. The subtyping hierarchy has to be defined as
 * follows:
 *
 * 
 *   T <: MonoT <: S
 * 
 *
 * where {@code <:} indicates the subtyping relation.
 *
 * 
 * An expression of a monotonic type can only be assigned expressions of the
 * target type {@code T}. This means that an expression of the monotonic type
 * {@code MonoT} cannot be assigned to a variable of the same type.
 *
 * 

 * Reading an expression of a monotonic type {@code MonoT} might always yield an
 * expression of type {@code S}. However, once it has been observed that a
 * variable has the target type {@code T}, the monotonic property ensures that
 * it will stay of type {@code T} for the rest of the program execution. This is
 * even true if arbitrary other code is executed.
 *
 * 
 * Note that variables of a monotonic type can be re-assigned arbitrarily often,
 * but only with expressions of the target type.
 *
 * @author Stefan Heule
 */
@Target({ ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface MonotonicQualifier {
    Class value();
}