org.checkerframework.framework.util.element

Class MethodTypeParamApplier

java.lang.Object

org.checkerframework.framework.util.element.MethodTypeParamApplier

public class MethodTypeParamApplier
extends Object

Applies the annotations present for a method type parameter onto an AnnotatedTypeVariable.

Field Summary

Fields

Modifier and Type	Field and Description
protected Element	element An Element that type represents.
protected AnnotatedTypeMirror	type The type to which we wish to apply annotations.
protected AnnotatedTypeFactory	typeFactory
protected AnnotatedTypeMirror.AnnotatedTypeVariable	typeParam

Method Summary

Modifier and Type	Method and Description
static boolean	accepts(AnnotatedTypeMirror type, Element element)
protected com.sun.tools.javac.code.TargetType[]	annotatedTargets()
static void	apply(AnnotatedTypeMirror.AnnotatedTypeVariable type, Element element, AnnotatedTypeFactory typeFactory)
void	extractAndApply() Reads the list of annotations that apply to this element (see getRawTypeAttributes).
int	getElementIndex() The index of element in the list of elements that contains it
protected Iterable<com.sun.tools.javac.code.Attribute.TypeCompound>	getRawTypeAttributes() Annotations on elements are represented as Attribute.TypeCompounds ( a subtype of AnnotationMirror) that are usually accessed through a getRawTypeAttributes method on the element.
int	getTypeCompoundIndex(com.sun.tools.javac.code.Attribute.TypeCompound anno) A TypeAnnotationPosition has a number of different indexes (type_index, bound_index, param_index) Return the index we are interested in.
protected void	handleInvalid(List<com.sun.tools.javac.code.Attribute.TypeCompound> invalid)
protected void	handleTargeted(List<com.sun.tools.javac.code.Attribute.TypeCompound> targeted) This method should apply all annotations that are handled by this object.
protected void	handleValid(List<com.sun.tools.javac.code.Attribute.TypeCompound> valid) The default implementation of this method does nothing.
protected boolean	isAccepted() Tests element/type fields to ensure that this TargetedElementAnnotationApplier is valid for this element/type pair.
protected com.sun.tools.javac.code.TargetType	lowerBoundTarget()
protected Map<org.checkerframework.framework.util.element.TargetedElementAnnotationApplier.TargetClass,List<com.sun.tools.javac.code.Attribute.TypeCompound>>	sift(Iterable<com.sun.tools.javac.code.Attribute.TypeCompound> typeCompounds) Separate the input annotations into a Map of TargetClass (TARGETED, VALID, INVALID) to the annotations that fall into each of those categories.
protected com.sun.tools.javac.code.TargetType	upperBoundTarget()
protected com.sun.tools.javac.code.TargetType[]	validTargets()

Methods inherited from class java.lang.Object

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

Field Detail

typeParam

protected final AnnotatedTypeMirror.AnnotatedTypeVariable typeParam

typeFactory

protected final AnnotatedTypeFactory typeFactory

type

protected final AnnotatedTypeMirror type

The type to which we wish to apply annotations.

element

protected final Element element

An Element that type represents.

Method Detail

apply

public static void apply(AnnotatedTypeMirror.AnnotatedTypeVariable type,
                         Element element,
                         AnnotatedTypeFactory typeFactory)

accepts

public static boolean accepts(AnnotatedTypeMirror type,
                              Element element)

Returns:

true if element represents a type parameter for a method

lowerBoundTarget

protected com.sun.tools.javac.code.TargetType lowerBoundTarget()

Returns:

TargetType.METHOD_TYPE_PARAMETER

upperBoundTarget

protected com.sun.tools.javac.code.TargetType upperBoundTarget()

Returns:

TargetType.METHOD_TYPE_PARAMETER_BOUND

getElementIndex

public int getElementIndex()

The index of element in the list of elements that contains it

Returns:

the index of element in the type parameter list of its enclosing method

validTargets

protected com.sun.tools.javac.code.TargetType[] validTargets()

Returns:

the TargetTypes that identify annotations that are valid but we wish to ignore. Any annotations that have these target types will be passed to handleValid, providing they aren't also in annotatedTargets.

getRawTypeAttributes

protected Iterable<com.sun.tools.javac.code.Attribute.TypeCompound> getRawTypeAttributes()

Annotations on elements are represented as Attribute.TypeCompounds ( a subtype of AnnotationMirror) that are usually accessed through a getRawTypeAttributes method on the element.

In Java 8 and later these annotations are generally contained by elements to which they apply. However, in earlier versions of Java many of these annotations are handled by either the enclosing method, e.g. parameters and method type parameters, or enclosing class, e.g. class type parameters. Therefore, many annotations are addressed by first getting all annotations on a method or class and the picking out only the ones we wish to target (see extractAndApply).

Returns:

the TypeCompounds (annotations) of the declaring element

isAccepted

protected boolean isAccepted()

Tests element/type fields to ensure that this TargetedElementAnnotationApplier is valid for this element/type pair.

Returns:

true if the type/element members are handled by this class false otherwise

annotatedTargets

protected com.sun.tools.javac.code.TargetType[] annotatedTargets()

Returns:

the lower bound and upper bound targets

getTypeCompoundIndex

public int getTypeCompoundIndex(com.sun.tools.javac.code.Attribute.TypeCompound anno)

A TypeAnnotationPosition has a number of different indexes (type_index, bound_index, param_index) Return the index we are interested in. If offsetting needs to be done it should be done in getElementIndex not here. (see ElementAnnotationUtils.getBoundIndexOffset )

Parameters:

anno - an annotation we might wish to apply

Returns:

the parameter_index of anno's TypeAnnotationPosition which will actually point to the type parameter's index in its enclosing type parameter list

handleTargeted

protected void handleTargeted(List<com.sun.tools.javac.code.Attribute.TypeCompound> targeted)

This method should apply all annotations that are handled by this object.

Parameters:

targeted - the list of annotations that were on the lower/upper bounds of the type parameter

Note: When handling type parameters we NEVER add primary annotations to the type parameter. Primary annotations are reserved for the use of a type parameter (e.g. @Nullable T t; )

If an annotation is present on the type parameter itself, it represents the lower-bound annotation of that type parameter. Any annotation on the extends bound of a type parameter is placed on that bound.

sift

protected Map<org.checkerframework.framework.util.element.TargetedElementAnnotationApplier.TargetClass,List<com.sun.tools.javac.code.Attribute.TypeCompound>> sift(Iterable<com.sun.tools.javac.code.Attribute.TypeCompound> typeCompounds)

Separate the input annotations into a Map of TargetClass (TARGETED, VALID, INVALID) to the annotations that fall into each of those categories.

Parameters:

typeCompounds - annotations to sift through, should be those returned by getRawTypeAttributes

Returns:

a Map<TargetClass &rArr; Annotations>.

handleValid

protected void handleValid(List<com.sun.tools.javac.code.Attribute.TypeCompound> valid)

The default implementation of this method does nothing.

Parameters:

valid - the list of annotations that were returned by getRawTypeAttributes and had a TargetType contained by valid and NOT annotatedTargets

handleInvalid

protected void handleInvalid(List<com.sun.tools.javac.code.Attribute.TypeCompound> invalid)

Parameters:

invalid - the list of annotations that were returned by getRawTypeAttributes and were not handled by handleTargeted or handleValid

extractAndApply

public void extractAndApply()

Reads the list of annotations that apply to this element (see getRawTypeAttributes). Sifts them into three groups (TARGETED, INVALID, VALID) and then calls the appropriate handle method on them. The handleTargeted method should apply all annotations that are handled by this object.

This method will throw a runtime exception if isAccepted returns false.