org.checkerframework.framework.util.typeinference.constraint

Class AFConstraint

java.lang.Object

org.checkerframework.framework.util.typeinference.constraint.AFConstraint

Direct Known Subclasses:

A2F, F2A, FIsA

public abstract class AFConstraint
extends Object

AFConstraint represent the initial constraints used to infer type arguments for method invocations and new class invocations. These constraints are simplified then converted to TUConstraints during type argument inference..

Subclasses of AFConstraint represent the following types of constraints found in (http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.7)

A 《 F and F 》 A both imply that A is convertible to F. F 《 A and A 》 F both imply that F is convertible to A (this may happen due to wildcard/typevar bounds and recursive types) A = F implies that A is exactly F

In the Checker Framework a type, A will be convertible to another type F, if AnnotatedTypes.asSuper will return a non-null value when A is passed as a subtype and F the supertype to the method.

In Java type A will be convertible to another type F if there exists a conversion context/method that transforms the one type into the other.

A 《 F and F 》 A are represented by class A2F F 《 A and A 》 F are represented by class F2A F = A is represented by class FIsA

Field Summary

Fields

Modifier and Type	Field and Description
AnnotatedTypeMirror	argument
AnnotatedTypeMirror	formalParameter
protected int	hashcodeBase Used to compute hashcodes.

Constructor Summary

Constructors

Constructor and Description
AFConstraint(AnnotatedTypeMirror argument, AnnotatedTypeMirror formalParameter, int hashcodeBase)

Method Summary

Modifier and Type	Method and Description
protected abstract AFConstraint	construct(AnnotatedTypeMirror newArgument, AnnotatedTypeMirror newFormalParameter) Used to create a new constraint of the same subclass of AFConstraint.
boolean	equals(Object thatObject)
int	hashCode()
boolean	isIrreducible(Set<TypeVariable> targets)
AFConstraint	substitute(Map<TypeVariable,AnnotatedTypeMirror> substitutions) Given a partial solution to our type argument inference, replace any uses of type parameters that have been solved with their arguments.
abstract TUConstraint	toTUConstraint() Once AFConstraints are irreducible it can be converted to a TU constraint, constraints between individual type parameters for which we are inferring an argument (T) and Java types (U).

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Field Detail

argument

public final AnnotatedTypeMirror argument

formalParameter

public final AnnotatedTypeMirror formalParameter

hashcodeBase

protected final int hashcodeBase

Used to compute hashcodes. This value should be unique for every subclass of AFConstraints.

Constructor Detail

AFConstraint

public AFConstraint(AnnotatedTypeMirror argument,
                    AnnotatedTypeMirror formalParameter,
                    int hashcodeBase)

Method Detail

isIrreducible

public boolean isIrreducible(Set<TypeVariable> targets)

Parameters:

targets - the type parameters whose arguments we are trying to solve for

Returns:

true if this constraint can't be broken up into other constraints or further simplified In general, if either argument or formal parameter is a use of the type parameters we are inferring over then the constraint cannot be reduced further

equals

public boolean equals(Object thatObject)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toTUConstraint

public abstract TUConstraint toTUConstraint()

Once AFConstraints are irreducible it can be converted to a TU constraint, constraints between individual type parameters for which we are inferring an argument (T) and Java types (U).

Returns:

a TUConstraint that represents this AFConstraint

substitute

public AFConstraint substitute(Map<TypeVariable,AnnotatedTypeMirror> substitutions)

Given a partial solution to our type argument inference, replace any uses of type parameters that have been solved with their arguments.

That is: Let S be a partial solution to our inference (i.e. we have inferred type arguments for some types) Let S be a map (T0 ⇒ A0, T1 ⇒ A1, ..., TN ⇒ AN) where Ti is a type parameter and Ai is its solved argument. For all uses of Ti in this constraint, replace them with Ai.

For the mapping (T0 ⇒ A0), the following constraint: ArrayList<T0> << List<T1>

Becomes: ArrayList<A0> << List<T1>

A constraint: T0 << T1

Becomes: A0 << T1

Parameters:

substitutions - a mapping of target type parameter to the type argument to

Returns:

a new constraint that contains no use of the keys in substitutions

construct

protected abstract AFConstraint construct(AnnotatedTypeMirror newArgument,
                                          AnnotatedTypeMirror newFormalParameter)

Used to create a new constraint of the same subclass of AFConstraint.