public abstract class AFConstraint extends Object
Subclasses of AFConstraint represent the following types of constraints:
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
Modifier and Type | Field and Description |
---|---|
AnnotatedTypeMirror |
argument
The argument type.
|
AnnotatedTypeMirror |
formalParameter
The formal parameter type.
|
Modifier | Constructor and Description |
---|---|
protected |
AFConstraint(AnnotatedTypeMirror argument,
AnnotatedTypeMirror formalParameter)
Create a constraint for type arguments for a methodd invocation or new class invocation.
|
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(@Nullable Object thatObject) |
int |
hashCode() |
boolean |
isIrreducible(Set<TypeVariable> targets)
Returns true if this constraint can't be broken up into other constraints or further
simplified.
|
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).
|
public final AnnotatedTypeMirror argument
public final AnnotatedTypeMirror formalParameter
protected AFConstraint(AnnotatedTypeMirror argument, AnnotatedTypeMirror formalParameter)
public boolean isIrreducible(Set<TypeVariable> targets)
targets
- the type parameters whose arguments we are trying to solve forpublic abstract TUConstraint toTUConstraint()
public AFConstraint substitute(Map<TypeVariable,AnnotatedTypeMirror> substitutions)
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
substitutions
- a mapping of target type parameter to the type argument toprotected abstract AFConstraint construct(AnnotatedTypeMirror newArgument, AnnotatedTypeMirror newFormalParameter)