Package spoon.support.reflect.reference

Class CtTypeReferenceImpl<T>

java.lang.Object

spoon.support.reflect.declaration.CtElementImpl

spoon.support.reflect.reference.CtReferenceImpl

spoon.support.reflect.reference.CtTypeReferenceImpl<T>

All Implemented Interfaces:

Serializable, Cloneable, FactoryAccessor, SourcePositionHolder, CtElement, CtShadowable, CtTypeInformation, CtActualTypeContainer, CtReference, CtTypeReference<T>, CtQueryable, CtVisitable

Direct Known Subclasses:

CtArrayTypeReferenceImpl, CtIntersectionTypeReferenceImpl, CtTypeParameterReferenceImpl

public class CtTypeReferenceImpl<T>
extends CtReferenceImpl
implements CtTypeReference<T>

See Also:

Serialized Form

Field Summary

Fields inherited from class spoon.support.reflect.reference.CtReferenceImpl

simplename

Fields inherited from class spoon.support.reflect.declaration.CtElementImpl

ERROR_MESSAGE_TO_STRING, factory, LOGGER, parent

Fields inherited from interface spoon.reflect.reference.CtTypeReference

NULL_TYPE_NAME, OMITTED_TYPE_ARG_NAME

Constructor Summary

Constructors

Constructor	Description
CtTypeReferenceImpl()

Method Summary

Modifier and Type	Method	Description
void	accept(CtVisitor visitor)	Accepts a visitor
<C extends CtActualTypeContainer> C	addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Adds a type argument.
CtIntersectionTypeReference<T>	asCtIntersectionTypeReference()	Casts the type reference in CtIntersectionTypeReference.
CtTypeReference<?>	box()	Returns the corresponding non-primitive type for a primitive type (the same type otherwise).
boolean	canAccess(CtTypeMember typeMember)
boolean	canAccess(CtTypeReference<?> type)	Checks visibility based on public, protected, package protected and private modifiers of type
CtTypeReference<T>	clone()	Clone the element which calls this method in a new object.
protected Class<T>	findClass()	Finds the class requested in getActualClass().
CtTypeReference<?>	getAccessType()	Computes nearest access path parent to this type from the context of this type reference.
protected AnnotatedElement	getActualAnnotatedElement()
Class<T>	getActualClass()	Gets the Java runtime class of the referenced type.
List<CtTypeReference<?>>	getActualTypeArguments()	Gets the type arguments.
Collection<CtExecutableReference<?>>	getAllExecutables()	Gets the executables declared by this type and by all its supertypes (static/instance methods, constructors, anonymous static blocks) if applicable.
Collection<CtFieldReference<?>>	getAllFields()	Gets the fields declared by this type and by all its supertypes if applicable.
CtType<T>	getDeclaration()	Returns the CtType, that corresponds to the reference or null if the type declaration is not in the analyzed source files, CtTypeReference.getTypeDeclaration() is a newer and better alternative that less often returns null.
Collection<CtExecutableReference<?>>	getDeclaredExecutables()	Gets the executables declared by this type if applicable.
CtFieldReference<?>	getDeclaredField(String name)	Gets a field from its name.
Collection<CtFieldReference<?>>	getDeclaredFields()	Gets the fields declared by this type.
CtFieldReference<?>	getDeclaredOrInheritedField(String fieldName)	Gets a field from this type or any super type or any implemented interface by field name.
CtTypeReference<?>	getDeclaringType()	Gets the type that declares the referenced type.
Set<ModifierKind>	getModifiers()	Gets modifiers of this type.
CtPackageReference	getPackage()	Gets the package of the referenced type.
String	getQualifiedName()	Returns the fully qualified name of this type declaration.
CtTypeReference<?>	getSuperclass()	Returns a reference to the type directly extended by this type.
Set<CtTypeReference<?>>	getSuperInterfaces()	Returns the interface types directly implemented by this class or extended by this interface.
CtTypeReference<?>	getTopLevelType()	Returns this, or top level type of this, if this is an inner type
CtType<T>	getTypeDeclaration()	Returns the CtType that corresponds to the reference even if the type isn't in the Spoon source path (in this case, the Spoon elements are built with runtime reflection, and the resulting CtType is called a "shadow" class, see CtShadowable.isShadow()).
CtTypeReference<?>	getTypeErasure()	This method returns a reference to the erased type.
CtTypeParameter	getTypeParameterDeclaration()	If this type reference is used as a type argument (see CtActualTypeContainer.getActualTypeArguments()), returns the type parameter declaration in the target type, returns null otherwise.
boolean	isAnnotationType()	Returns true if this type is an annotation type.
boolean	isAnonymous()	Return true if the referenced type is an anonymous type
boolean	isArray()	Returns true if this type represents an array like Object[] or int[].
boolean	isClass()	Returns true if this type is a class.
boolean	isEnum()	Returns true if this type is an enum.
boolean	isGenerics()	Returns true if it is not a concrete, resolvable class, it if refers to a type parameter directly or indirectly.
boolean	isInterface()	Returns true if this type is an interface.
boolean	isLocalType()	Returns true if the referenced type is declared in an executable.
boolean	isParameterized()	Returns true if it has any type parameter (generic or not).
boolean	isPrimitive()	Checks if the referenced type is a primitive type.
boolean	isShadow()	When an element isn't present in the factory (created in another factory), this element is considered as "shadow".
boolean	isSimplyQualified()
boolean	isSubtypeOf(CtTypeReference<?> type)	Checks if this type is a subtype of the given type.
boolean	removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Removes a type argument.
<C extends CtActualTypeContainer> C	setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Sets the type arguments.
<C extends CtTypeReference<T>> C	setDeclaringType(CtTypeReference<?> declaringType)	Sets the reference to the declaring type.
<C extends CtTypeReference<T>> C	setPackage(CtPackageReference pack)	Sets the reference to the declaring package.
<E extends CtShadowable> E	setShadow(boolean isShadow)	Marks an element as shadow.
CtTypeReferenceImpl<T>	setSimplyQualified(boolean isSimplyQualified)
CtTypeReference<?>	unbox()	Returns the primitive type for a boxing type (unchanged if the type does not correspond to a boxing type).

Methods inherited from class spoon.support.reflect.reference.CtReferenceImpl

equals, getSimpleName, setComments, setSimpleName

Methods inherited from class spoon.support.reflect.declaration.CtElementImpl

addAnnotation, addComment, asIterable, comment, delete, descendantIterator, emptyList, emptySet, filterChildren, getAllMetadata, getAnnotatedChildren, getAnnotation, getAnnotation, getAnnotations, getComments, getDirectChildren, getDocComment, getElements, getFactory, getMetadata, getMetadataKeys, getOriginalSourceFragment, getParent, getParent, getParent, getPath, getPosition, getReferencedTypes, getRoleInParent, getShortRepresentation, getValueByRole, hasAnnotation, hashCode, hasParent, isImplicit, isParentInitialized, map, map, prettyprint, putMetadata, removeAnnotation, removeComment, replace, replace, setAllMetadata, setAnnotations, setDocComment, setFactory, setImplicit, setParent, setPosition, setPositions, setValueByRole, toString, toStringDebug, unmodifiableList, updateAllParentsBelow

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface spoon.reflect.declaration.CtElement

addAnnotation, addComment, asIterable, delete, descendantIterator, getAllMetadata, getAnnotatedChildren, getAnnotation, getAnnotation, getAnnotations, getComments, getDirectChildren, getDocComment, getElements, getMetadata, getMetadataKeys, getOriginalSourceFragment, getParent, getParent, getParent, getPath, getPosition, getReferencedTypes, getRoleInParent, getShortRepresentation, getValueByRole, hasAnnotation, hasParent, isImplicit, isParentInitialized, prettyprint, putMetadata, removeAnnotation, removeComment, replace, replace, setAllMetadata, setAnnotations, setDocComment, setImplicit, setParent, setPosition, setPositions, setValueByRole, toString, toStringDebug, updateAllParentsBelow

Methods inherited from interface spoon.reflect.visitor.chain.CtQueryable

filterChildren, map, map

Methods inherited from interface spoon.reflect.reference.CtReference

setComments, setSimpleName

Methods inherited from interface spoon.reflect.reference.CtTypeReference

getSimpleName

Methods inherited from interface spoon.processing.FactoryAccessor

getFactory, setFactory

Constructor Details

CtTypeReferenceImpl

public CtTypeReferenceImpl()

Method Details

accept

public void accept(CtVisitor visitor)

Description copied from interface: CtVisitable

Accepts a visitor

Specified by:

accept in interface CtVisitable

box

public CtTypeReference<?> box()

Description copied from interface: CtTypeReference

Returns the corresponding non-primitive type for a primitive type (the same type otherwise).

Specified by:

box in interface CtTypeReference<T>

getActualClass

public Class<T> getActualClass()

Description copied from interface: CtTypeReference

Gets the Java runtime class of the referenced type. This is a low-level feature, it should never been used, use CtTypeReference.getTypeDeclaration() instead in order to only stay in the Spoon world and manipulate CtType instead of java.lang.Class.

Note (these are artifacts of the current implementation and might change at any time):

1. it will return the version of the class your Environment.getInputClassLoader() loads. This might be a version spoon compiled (manually using SpoonModelBuilder.compile(spoon.SpoonModelBuilder.InputType...) or implicitly using Environment.shouldCompile()) or from your classpath (which might be null)
2. it will run static initializers (executing arbitrary code from the analyzed project in the process)
3. it will fail if the static initializers of the class fail
4. the Class object may not reflect the CtType in case you made recent changes to it based on point 1

Specified by:

getActualClass in interface CtTypeReference<T>

Returns:

the Java class or throws a SpoonClassNotFoundException if the class is not found.

findClass

protected Class<T> findClass()

Finds the class requested in getActualClass(). Looks for the class in the standard Java classpath, but also in the sourceClassPath given as option.

getActualTypeArguments

public List<CtTypeReference<?>> getActualTypeArguments()

Description copied from interface: CtActualTypeContainer

Gets the type arguments.

Specified by:

getActualTypeArguments in interface CtActualTypeContainer

getActualAnnotatedElement

protected AnnotatedElement getActualAnnotatedElement()

Specified by:

getActualAnnotatedElement in class CtReferenceImpl

getDeclaration

public CtType<T> getDeclaration()

Description copied from interface: CtTypeReference

Returns the CtType, that corresponds to the reference or null if the type declaration is not in the analyzed source files, CtTypeReference.getTypeDeclaration() is a newer and better alternative that less often returns null.

Specified by:

getDeclaration in interface CtReference

Specified by:

getDeclaration in interface CtTypeReference<T>

Returns:

the referenced element or null if the type declaration is not the analyzed source files.

getTypeDeclaration

public CtType<T> getTypeDeclaration()

Description copied from interface: CtTypeReference

Returns the CtType that corresponds to the reference even if the type isn't in the Spoon source path (in this case, the Spoon elements are built with runtime reflection, and the resulting CtType is called a "shadow" class, see CtShadowable.isShadow()).

Specified by:

getTypeDeclaration in interface CtTypeReference<T>

Returns:

the type declaration that corresponds to the reference or null if the reference points to a class that is not in the classpath.

getDeclaringType

public CtTypeReference<?> getDeclaringType()

Description copied from interface: CtTypeReference

Gets the type that declares the referenced type.

Specified by:

getDeclaringType in interface CtTypeReference<T>

Returns:

the declaring type if this references an inner class; null in other cases

getPackage

public CtPackageReference getPackage()

Description copied from interface: CtTypeReference

Gets the package of the referenced type.

Specified by:

getPackage in interface CtTypeReference<T>

Returns:

the declaring package or null if this if a inner class

getQualifiedName

public String getQualifiedName()

Description copied from interface: CtTypeInformation

Returns the fully qualified name of this type declaration.

Specified by:

getQualifiedName in interface CtTypeInformation

isPrimitive

public boolean isPrimitive()

Description copied from interface: CtTypeInformation

Checks if the referenced type is a primitive type.

It is a primitive type, if it is one of the following types:

• byte
• short
• int
• long
• float
• double
• boolean
• char
• void

For boxed types like Integer this method returns false.

Specified by:

isPrimitive in interface CtTypeInformation

Returns:

true if the referenced type is a primitive type

isSubtypeOf

public boolean isSubtypeOf(CtTypeReference<?> type)

Description copied from interface: CtTypeInformation

Checks if this type is a subtype of the given type.

Specified by:

isSubtypeOf in interface CtTypeInformation

Parameters:

type - the type that might be a parent of this type.

Returns:

true if the referenced type is a subtype of the given type, otherwise false. If this type is the same as the given type (typeX.isSubtypeOf(typeX)), this method returns true.

setActualTypeArguments

public <C extends CtActualTypeContainer> C setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)

Description copied from interface: CtActualTypeContainer

Sets the type arguments.

Specified by:

setActualTypeArguments in interface CtActualTypeContainer

setDeclaringType

public <C extends CtTypeReference<T>> C setDeclaringType(CtTypeReference<?> declaringType)

Description copied from interface: CtTypeReference

Sets the reference to the declaring type. Should be set to null if the referenced type is not a inner type.

Specified by:

setDeclaringType in interface CtTypeReference<T>

setPackage

public <C extends CtTypeReference<T>> C setPackage(CtPackageReference pack)

Description copied from interface: CtTypeReference

Sets the reference to the declaring package.

Specified by:

setPackage in interface CtTypeReference<T>

asCtIntersectionTypeReference

public CtIntersectionTypeReference<T> asCtIntersectionTypeReference()

Description copied from interface: CtTypeReference

Casts the type reference in CtIntersectionTypeReference.

Specified by:

asCtIntersectionTypeReference in interface CtTypeReference<T>

unbox

public CtTypeReference<?> unbox()

Description copied from interface: CtTypeReference

Returns the primitive type for a boxing type (unchanged if the type does not correspond to a boxing type).

Specified by:

unbox in interface CtTypeReference<T>

getDeclaredFields

public Collection<CtFieldReference<?>> getDeclaredFields()

Description copied from interface: CtTypeInformation

Gets the fields declared by this type.

Specified by:

getDeclaredFields in interface CtTypeInformation

getDeclaredField

public CtFieldReference<?> getDeclaredField(String name)

Description copied from interface: CtTypeInformation

Gets a field from its name.

Specified by:

getDeclaredField in interface CtTypeInformation

Returns:

a reference to the field with the name or null if it does not exist

getDeclaredOrInheritedField

public CtFieldReference<?> getDeclaredOrInheritedField(String fieldName)

Description copied from interface: CtTypeInformation

Gets a field from this type or any super type or any implemented interface by field name.

Specified by:

getDeclaredOrInheritedField in interface CtTypeInformation

Returns:

a reference to the field with the name or null if it does not exist

getDeclaredExecutables

public Collection<CtExecutableReference<?>> getDeclaredExecutables()

Description copied from interface: CtTypeInformation

Gets the executables declared by this type if applicable.

Specified by:

getDeclaredExecutables in interface CtTypeInformation

getAllFields

public Collection<CtFieldReference<?>> getAllFields()

Description copied from interface: CtTypeInformation

Gets the fields declared by this type and by all its supertypes if applicable.

Specified by:

getAllFields in interface CtTypeInformation

getAllExecutables

public Collection<CtExecutableReference<?>> getAllExecutables()

Description copied from interface: CtTypeInformation

Gets the executables declared by this type and by all its supertypes (static/instance methods, constructors, anonymous static blocks) if applicable. This method returns:

• static, instance and default methods
• constructors

If a method is overridden twice in the hierarchy, it counts for two different elements. The method can be abstract.

Specified by:

getAllExecutables in interface CtTypeInformation

getModifiers

public Set<ModifierKind> getModifiers()

Description copied from interface: CtTypeInformation

Gets modifiers of this type.

Specified by:

getModifiers in interface CtTypeInformation

Specified by:

getModifiers in interface CtTypeReference<T>

getSuperclass

public CtTypeReference<?> getSuperclass()

Description copied from interface: CtTypeInformation

Returns a reference to the type directly extended by this type.

To get the CtType of the super class, use CtTypeReference.getDeclaration() or CtTypeReference.getTypeDeclaration() on the CtTypeReference returned by this method.

Specified by:

getSuperclass in interface CtTypeInformation

Specified by:

getSuperclass in interface CtTypeReference<T>

Returns:

the type explicitly extended by this type, or null if there is none or if the super type is not in the classpath (in noclasspath mode). If a class does not explicitly extend another class null is returned (not Object). For types like enums that implicitly extend a superclass like Enum, this method returns that class.

getSuperInterfaces

public Set<CtTypeReference<?>> getSuperInterfaces()

Description copied from interface: CtTypeInformation

Returns the interface types directly implemented by this class or extended by this interface.

Specified by:

getSuperInterfaces in interface CtTypeInformation

Specified by:

getSuperInterfaces in interface CtTypeReference<T>

isAnonymous

public boolean isAnonymous()

Description copied from interface: CtTypeInformation

Return true if the referenced type is an anonymous type

Specified by:

isAnonymous in interface CtTypeInformation

isLocalType

public boolean isLocalType()

Description copied from interface: CtTypeInformation

Returns true if the referenced type is declared in an executable. e.g. a type declared in a method or a lambda. This corresponds to isLocalClass of java.lang.Class.

     // Type declared in a method.
     public void make() {
         class Cook {
         }
     }
     // Type declared in a lambda.
     s -> {
         class Cook {
         }
     }
 

Specified by:

isLocalType in interface CtTypeInformation

addActualTypeArgument

public <C extends CtActualTypeContainer> C addActualTypeArgument(CtTypeReference<?> actualTypeArgument)

Description copied from interface: CtActualTypeContainer

Adds a type argument.

Specified by:

addActualTypeArgument in interface CtActualTypeContainer

removeActualTypeArgument

public boolean removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)

Description copied from interface: CtActualTypeContainer

Removes a type argument.

Specified by:

removeActualTypeArgument in interface CtActualTypeContainer

isClass

public boolean isClass()

Description copied from interface: CtTypeInformation

Returns true if this type is a class. Returns false for others (enum, interface, generics, annotation).

Specified by:

isClass in interface CtTypeInformation

isInterface

public boolean isInterface()

Description copied from interface: CtTypeInformation

Returns true if this type is an interface.

Specified by:

isInterface in interface CtTypeInformation

isAnnotationType

public boolean isAnnotationType()

Description copied from interface: CtTypeInformation

Returns true if this type is an annotation type.

Specified by:

isAnnotationType in interface CtTypeInformation

isEnum

public boolean isEnum()

Description copied from interface: CtTypeInformation

Returns true if this type is an enum.

Specified by:

isEnum in interface CtTypeInformation

canAccess

public boolean canAccess(CtTypeReference<?> type)

Description copied from interface: CtTypeReference

Checks visibility based on public, protected, package protected and private modifiers of type

Specified by:

canAccess in interface CtTypeReference<T>

Returns:

true if this can access that type

canAccess

public boolean canAccess(CtTypeMember typeMember)

Specified by:

canAccess in interface CtTypeReference<T>

Returns:

true if this type can access that the `typeMember` in another type based on public, protected, package protected and private modifiers.

getTopLevelType

public CtTypeReference<?> getTopLevelType()

Description copied from interface: CtTypeReference

Returns this, or top level type of this, if this is an inner type

Specified by:

getTopLevelType in interface CtTypeReference<T>

getAccessType

public CtTypeReference<?> getAccessType()

Description copied from interface: CtTypeReference

Computes nearest access path parent to this type from the context of this type reference. The context is defined by this.getParent(CtType.class). Normally the declaring type can be used as access path. For example in this class hierarchy

 class A {
    class B {
       class C {}
    }
 }
 

The C.getAccessParentFrom(null) will return B, because B can be used to access C, using code like B.C
But when some class (A or B) on the access path is not visible in type X, then we must found an alternative path. For example in case like, when A and B are invisible, e.g because of modifier protected:

 class D extends B {
 }
 class X extends D {
         class F extends C
 }
 

The C.getAccessParentFrom(X) will return D, because D can be used to access C in scope of X.

Specified by:

getAccessType in interface CtTypeReference<T>

Returns:

type reference which can be used to access this type in scope of contextType.

isShadow

public boolean isShadow()

Description copied from interface: CtShadowable

When an element isn't present in the factory (created in another factory), this element is considered as "shadow". e.g., a shadow element can be a CtType of java.lang.Class built when we call CtTypeReference.getTypeDeclaration() on a reference of java.lang.Class.

Specified by:

isShadow in interface CtShadowable

Returns:

true if the element is a shadow element, otherwise false.

setShadow

public <E extends CtShadowable> E setShadow(boolean isShadow)

Description copied from interface: CtShadowable

Marks an element as shadow. To know what is a shadow element, see the javadoc of CtShadowable.isShadow().

Specified by:

setShadow in interface CtShadowable

clone

public CtTypeReference<T> clone()

Description copied from interface: CtElement

Clone the element which calls this method in a new object. Note that that references are kept as is, and thus, so if you clone whole classes or methods, some parts of the cloned element (eg executable references) may still point to the initial element. In this case, consider using methods Refactoring.copyType(CtType) and Refactoring.copyMethod(CtMethod) instead which does additional work beyond cloning.

Specified by:

clone in interface CtElement

Specified by:

clone in interface CtReference

Specified by:

clone in interface CtTypeReference<T>

Overrides:

clone in class CtReferenceImpl

getTypeParameterDeclaration

public CtTypeParameter getTypeParameterDeclaration()

Description copied from interface: CtTypeReference

If this type reference is used as a type argument (see CtActualTypeContainer.getActualTypeArguments()), returns the type parameter declaration in the target type, returns null otherwise. In the following example, getTypeParameterDeclaration of "String" returns the type parameter definition "X".

 class Dog<X>{}
 Dog<String>var = ...;
 

In this other example, getTypeParameterDeclaration of T in Dog<T> returns the type parameter definition "X" (while CtTypeReference.getDeclaration() returns the "T" of Cat).

 class Dog<X>{}
 class Cat<T> {
 Dog<T> dog;
 }
 

Specified by:

getTypeParameterDeclaration in interface CtTypeReference<T>

isGenerics

public boolean isGenerics()

Description copied from interface: CtTypeInformation

Returns true if it is not a concrete, resolvable class, it if refers to a type parameter directly or indirectly. Direct: "T foo" isGenerics returns true. Indirect: List<T>, or Set<List<T>> isGenerics returns true

Specified by:

isGenerics in interface CtTypeInformation

isParameterized

public boolean isParameterized()

Description copied from interface: CtTypeInformation

Returns true if it has any type parameter (generic or not).

Specified by:

isParameterized in interface CtTypeInformation

getTypeErasure

public CtTypeReference<?> getTypeErasure()

Description copied from interface: CtTypeInformation

This method returns a reference to the erased type.

For example, this will return List for List<String>, or Enum for the type parameter E in the enum declaration.

Specified by:

getTypeErasure in interface CtTypeInformation

Returns:

a reference to the erased type

See Also:

Type Erasure

isSimplyQualified

public boolean isSimplyQualified()

Specified by:

isSimplyQualified in interface CtTypeReference<T>

Returns:

false then fully qualified name is printed. true then type simple name is printed.

setSimplyQualified

public CtTypeReferenceImpl<T> setSimplyQualified(boolean isSimplyQualified)

Specified by:

setSimplyQualified in interface CtTypeReference<T>

Parameters:

isSimplyQualified - false then the reference is printed fully qualified name. true then only the type name is printed.

isArray

public boolean isArray()

Description copied from interface: CtTypeInformation

Returns true if this type represents an array like Object[] or int[].

Specified by:

isArray in interface CtTypeInformation

Returns:

true if this type represents an array like Object[] or int[]