Uses of Interface
spoon.reflect.reference.CtTypeReference

Packages that use CtTypeReference

Package	Description
spoon.metamodel	Ready to go meta? This package contains classes that model the Spoon metamodel itself.
spoon.pattern
spoon.reflect.code	This package contains the meta-model part that models the executable code (methods and constructors' bodies, field initializers).
spoon.reflect.declaration	This package contains the meta-model part that models the declarations (program's structures such as classes, fields, etc).
spoon.reflect.factory	This package defines all the sub-factories for the Spoon meta-model.
spoon.reflect.reference	This package defines the references to program elements for the meta-model.
spoon.reflect.visitor	This package defines visitor, scanner, and scanner-based query API for Java programs reified in the meta-model.
spoon.reflect.visitor.filter	This package contains a set of useful filters when querying the model.
spoon.support	This package contains some default implementations for commonly used processing tasks.
spoon.support.adaption
spoon.support.compiler
spoon.support.compiler.jdt
spoon.support.reflect.code
spoon.support.reflect.declaration
spoon.support.reflect.reference
spoon.support.visitor
spoon.support.visitor.clone
spoon.support.visitor.java.internal
spoon.support.visitor.replace
spoon.template	This package defines a framework for well-typed pure-Java templates.

Uses of CtTypeReference in spoon.metamodel

Methods in spoon.metamodel that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<?>	MMMethod.getReturnType()
CtTypeReference<?>	MetamodelProperty.getTypeOfField()	Return the type of the field for List<String> field the ValueType is List for String field the ValueType is String
CtTypeReference<?>	MetamodelProperty.getTypeofItems()	Returns the type of the property for List<String> field the ValueType is String for String field the ValueType is String (when getContainerKind == ContainerKind.SINGLE, MetamodelProperty.getTypeofItems() == MetamodelProperty.getTypeOfField().
CtTypeReference<?>	MMMethod.getValueType()

Uses of CtTypeReference in spoon.pattern

Methods in spoon.pattern with parameters of type CtTypeReference

Modifier and Type	Method	Description
PatternParameterConfigurator	PatternParameterConfigurator.byType(CtTypeReference<?> type)	type referred by CtTypeReference `type` and all the references (with same actual type arguments) to that type are subject for substitution by current parameter

Uses of CtTypeReference in spoon.reflect.code

Methods in spoon.reflect.code that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<A>	CtTypeAccess.getAccessedType()	Returns type represented and contained in the type access.
CtTypeReference<T>	CtCatchVariable.getType()	Returns type reference of the exception variable in a catch.
CtTypeReference<T>	CtConstructorCall.getType()
CtTypeReference<T>	CtInvocation.getType()	Return the type returned by the invocation.
CtTypeReference<T>	CtSuperAccess.getType()
CtTypeReference<Void>	CtTypeAccess.getType()	Returns always VOID.
CtTypeReference<T>	CtVariableAccess.getType()

Methods in spoon.reflect.code that return types with arguments of type CtTypeReference

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtConstructorCall.getActualTypeArguments()	Delegate to the executable reference of the constructor call.
List<CtTypeReference<?>>	CtInvocation.getActualTypeArguments()	Delegate to the executable reference of the invocation.
List<CtTypeReference<?>>	CtNewClass.getActualTypeArguments()	Delegate to the executable reference of the new class.
List<CtTypeReference<?>>	CtExpression.getTypeCasts()	Returns the type casts if any.
List<CtTypeReference<?>>	CtTypePattern.getTypeCasts()

Methods in spoon.reflect.code with parameters of type CtTypeReference

Modifier and Type	Method	Description
<T extends CtActualTypeContainer> T	CtConstructorCall.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Delegate to the executable reference of the constructor call.
<T extends CtActualTypeContainer> T	CtInvocation.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Delegate to the executable reference of the invocation.
<T extends CtActualTypeContainer> T	CtNewClass.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Delegate to the executable reference of the new class.
<C extends CtExpression<T>> C	CtExpression.addTypeCast(CtTypeReference<?> type)	Adds a type cast.
<C extends CtExpression<Void>> C	CtTypePattern.addTypeCast(CtTypeReference<?> type)
<C extends CtTypeAccess<A>> C	CtTypeAccess.setAccessedType(CtTypeReference<A> accessedType)	Set the accessed type.
<C extends CtTypedElement> C	CtCatchVariable.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtTypeAccess.setType(CtTypeReference type)

Method parameters in spoon.reflect.code with type arguments of type CtTypeReference

Modifier and Type	Method	Description
<T extends CtActualTypeContainer> T	CtConstructorCall.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Delegate to the executable reference of the constructor call.
<T extends CtActualTypeContainer> T	CtInvocation.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Delegate to the executable reference of the invocation.
<T extends CtActualTypeContainer> T	CtNewClass.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Delegate to the executable reference of the new class.
<T1 extends CtExecutable<T>> T1	CtLambda.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtExpression<T>> C	CtExpression.setTypeCasts(List<CtTypeReference<?>> types)	Sets the type casts.
<C extends CtExpression<Void>> C	CtTypePattern.setTypeCasts(List<CtTypeReference<?>> types)

Uses of CtTypeReference in spoon.reflect.declaration

Methods in spoon.reflect.declaration that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<A>	CtAnnotation.getAnnotationType()	Returns the annotation type of this annotation.
CtTypeReference<T>	CtType.getReference()	Returns the corresponding type reference.
CtTypeReference	CtProvidedService.getServiceType()
CtTypeReference	CtUsedService.getServiceType()
CtTypeReference<?>	CtTypeInformation.getSuperclass()	Returns the class type directly extended by this class.
CtTypeReference<T>	CtTypedElement.getType()	Gets this element's type.
CtTypeReference<?>	CtTypeInformation.getTypeErasure()

Methods in spoon.reflect.declaration that return types with arguments of type CtTypeReference

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtCompilationUnit.getDeclaredTypeReferences()	Gets references to all the types declared in this compilation unit.
List<CtTypeReference>	CtProvidedService.getImplementationTypes()
List<CtTypeReference<?>>	CtMultiTypedElement.getMultiTypes()	Gets all types of the element.
Set<CtTypeReference<?>>	CtEnum.getPermittedTypes()
Set<CtTypeReference<?>>	CtRecord.getPermittedTypes()
Set<CtTypeReference<?>>	CtSealable.getPermittedTypes()	Returns the permitted types for this type.
Set<CtTypeReference<?>>	CtElement.getReferencedTypes()	Calculates and returns the set of all the types referenced by this element (and sub-elements in the AST).
Set<CtTypeReference<?>>	CtTypeInformation.getSuperInterfaces()	Returns the interface types directly implemented by this class or extended by this interface.
Set<CtTypeReference<? extends Throwable>>	CtExecutable.getThrownTypes()	Returns the exceptions and other throwables listed in this method or constructor's throws clause.
Set<CtTypeReference<?>>	CtType.getUsedTypes(boolean includeSamePackage)	Returns the types used by this type.

Methods in spoon.reflect.declaration with parameters of type CtTypeReference

Modifier and Type	Method	Description
CtCompilationUnit	CtCompilationUnit.addDeclaredTypeReference(CtTypeReference<?> type)	Add a type reference to the list of declared types
<T extends CtProvidedService> T	CtProvidedService.addImplementationType(CtTypeReference usedType)
<T extends CtMultiTypedElement> T	CtMultiTypedElement.addMultiType(CtTypeReference<?> ref)	Adds a type for the element.
CtEnum<T>	CtEnum.addPermittedType(CtTypeReference<?> type)
CtRecord	CtRecord.addPermittedType(CtTypeReference<?> type)
CtSealable	CtSealable.addPermittedType(CtTypeReference<?> type)	Adds a permitted type to this type.
<S, C extends CtType<T>> C	CtType.addSuperInterface(CtTypeReference<S> interfac)
<S, C extends CtType<Object>> C	CtTypeParameter.addSuperInterface(CtTypeReference<S> interfac)
<T extends CtExecutable<Void>> T	CtAnonymousExecutable.addThrownType(CtTypeReference<? extends Throwable> throwType)
<T extends CtExecutable<R>> T	CtExecutable.addThrownType(CtTypeReference<? extends Throwable> throwType)	add a thrown type.
<A extends Annotation> CtAnnotation<A>	CtElement.getAnnotation(CtTypeReference<A> annotationType)	Gets the annotation element for a given annotation type.
CtConstructor<T>	CtClass.getConstructor(CtTypeReference<?>... parameterTypes)	Returns the constructor of the class that takes the given argument types.
<R> CtMethod<R>	CtType.getMethod(String name, CtTypeReference<?>... parameterTypes)	Gets a method from its name and parameter types.
<R> CtMethod<R>	CtType.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)	Gets a method from its return type, name, and parameter types.
Set<CtMethod<?>>	CtType.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes)	Returns the methods that are directly declared by this class or interface and annotated with one of the given annotations.
boolean	CtTypeInformation.isSubtypeOf(CtTypeReference<?> type)	Returns true if the referenced type is a sub-type of the given type.
boolean	CtMultiTypedElement.removeMultiType(CtTypeReference<?> ref)	Removes a type for the element.
CtEnum<T>	CtEnum.removePermittedType(CtTypeReference<?> type)
CtRecord	CtRecord.removePermittedType(CtTypeReference<?> type)
CtSealable	CtSealable.removePermittedType(CtTypeReference<?> type)	Adds a permitted type to this type.
<S> boolean	CtType.removeSuperInterface(CtTypeReference<S> interfac)
boolean	CtExecutable.removeThrownType(CtTypeReference<? extends Throwable> throwType)	remove a thrown type.
<T extends CtAnnotation<A>> T	CtAnnotation.setAnnotationType(CtTypeReference<? extends Annotation> type)	Sets the annotation's type.
<T extends CtProvidedService> T	CtProvidedService.setServiceType(CtTypeReference providingType)
<T extends CtUsedService> T	CtUsedService.setServiceType(CtTypeReference providingType)
<C extends CtType<T>> C	CtAnnotationType.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtEnum.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtInterface.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<Object>> C	CtRecord.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtType.setSuperclass(CtTypeReference<?> superClass)	Sets the superclass type.
<C extends CtTypedElement> C	CtAnonymousExecutable.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtConstructor.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtTypedElement.setType(CtTypeReference type)	Sets this element's type.

Method parameters in spoon.reflect.declaration with type arguments of type CtTypeReference

Modifier and Type	Method	Description
CtCompilationUnit	CtCompilationUnit.setDeclaredTypeReferences(List<CtTypeReference<?>> types)	Sets the references to types declared in this compilation unit.
<T extends CtProvidedService> T	CtProvidedService.setImplementationTypes(List<CtTypeReference> usedTypes)
<T extends CtMultiTypedElement> T	CtMultiTypedElement.setMultiTypes(List<CtTypeReference<?>> types)	Adds a type for the element.
CtEnum<T>	CtEnum.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtRecord	CtRecord.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtSealable	CtSealable.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)	Sets the permitted types for this type.
<C extends CtType<T>> C	CtAnnotationType.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<T>> C	CtType.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)	Sets the super interfaces of this type.
<C extends CtType<Object>> C	CtTypeParameter.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<T1 extends CtExecutable<T>> T1	CtAnnotationMethod.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T extends CtExecutable<Void>> T	CtAnonymousExecutable.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T extends CtExecutable<R>> T	CtExecutable.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)	Sets the thrown types.
<C extends CtExpression<A>> C	CtAnnotation.setTypeCasts(List<CtTypeReference<?>> types)

Uses of CtTypeReference in spoon.reflect.factory

Fields in spoon.reflect.factory declared as CtTypeReference

Modifier and Type	Field	Description
CtTypeReference<Boolean>	TypeFactory.BOOLEAN
CtTypeReference<Boolean>	TypeFactory.BOOLEAN_PRIMITIVE
CtTypeReference<Byte>	TypeFactory.BYTE
CtTypeReference<Byte>	TypeFactory.BYTE_PRIMITIVE
CtTypeReference<Character>	TypeFactory.CHARACTER
CtTypeReference<Character>	TypeFactory.CHARACTER_PRIMITIVE
CtTypeReference<Collection>	TypeFactory.COLLECTION
CtTypeReference<Date>	TypeFactory.DATE
CtTypeReference<Double>	TypeFactory.DOUBLE
CtTypeReference<Double>	TypeFactory.DOUBLE_PRIMITIVE
CtTypeReference<Enum>	TypeFactory.ENUM
CtTypeReference<Float>	TypeFactory.FLOAT
CtTypeReference<Float>	TypeFactory.FLOAT_PRIMITIVE
CtTypeReference<Integer>	TypeFactory.INTEGER
CtTypeReference<Integer>	TypeFactory.INTEGER_PRIMITIVE
CtTypeReference<Iterable>	TypeFactory.ITERABLE
CtTypeReference<List>	TypeFactory.LIST
CtTypeReference<Long>	TypeFactory.LONG
CtTypeReference<Long>	TypeFactory.LONG_PRIMITIVE
CtTypeReference<Map>	TypeFactory.MAP
CtTypeReference<?>	TypeFactory.NULL_TYPE
CtTypeReference<Object>	TypeFactory.OBJECT
CtTypeReference<?>	TypeFactory.OMITTED_TYPE_ARG_TYPE
CtTypeReference<Set>	TypeFactory.SET
CtTypeReference<Short>	TypeFactory.SHORT
CtTypeReference<Short>	TypeFactory.SHORT_PRIMITIVE
CtTypeReference<String>	TypeFactory.STRING
CtTypeReference<Void>	TypeFactory.VOID
CtTypeReference<Void>	TypeFactory.VOID_PRIMITIVE

Methods in spoon.reflect.factory that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<Boolean>	TypeFactory.booleanPrimitiveType()	Returns a reference on the boolean primitive type.
CtTypeReference<Boolean>	TypeFactory.booleanType()	Returns a reference on the boolean type.
CtTypeReference<Byte>	TypeFactory.bytePrimitiveType()	Returns a reference on the byte primitive type.
CtTypeReference<Byte>	TypeFactory.byteType()	Returns a reference on the byte type.
CtTypeReference<Character>	TypeFactory.characterPrimitiveType()	Returns a reference on the character primitive type.
CtTypeReference<Character>	TypeFactory.characterType()	Returns a reference on the character type.
<T> CtTypeReference<T>	CodeFactory.createCtTypeReference(Class<?> originalClass)	Creates a type reference.
<T> CtTypeReference<T>	Factory.createCtTypeReference(Class<?> originalClass)
<T> CtTypeReference<T>	FactoryImpl.createCtTypeReference(Class<?> originalClass)
<T> CtTypeReference<T>	Factory.createReference(String qualifiedName)
<T> CtTypeReference<T>	FactoryImpl.createReference(String qualifiedName)
<T> CtTypeReference<T>	TypeFactory.createReference(Class<T> type)
<T> CtTypeReference<T>	TypeFactory.createReference(Class<T> type, boolean includingFormalTypeParameter)	Creates a reference to a simple type
<T> CtTypeReference<T>	TypeFactory.createReference(String qualifiedName)	Create a reference to a simple type
<T> CtTypeReference<T>	TypeFactory.createReference(CtType<T> type)	Create a reference to a simple type
<T> CtTypeReference<T>	TypeFactory.createReference(CtType<T> type, boolean includingFormalTypeParameter)
<T> CtTypeReference<T>	Factory.createSimplyQualifiedReference(String qualifiedName)
<T> CtTypeReference<T>	FactoryImpl.createSimplyQualifiedReference(String qualifiedName)
<T> CtTypeReference<T>	TypeFactory.createSimplyQualifiedReference(String qualifiedName)	Create a reference to a simple type, setting the beginning of its fully qualified name as implicit
<T> CtTypeReference<T>	CoreFactory.createTypeReference()	Creates a type reference.
<T> CtTypeReference<T>	Factory.createTypeReference()
<T> CtTypeReference<T>	FactoryImpl.createTypeReference()
CtTypeReference<Date>	TypeFactory.dateType()	Returns a reference on the date type.
CtTypeReference<Double>	TypeFactory.doublePrimitiveType()	Returns a reference on the double primitive type.
CtTypeReference<Double>	TypeFactory.doubleType()	Returns a reference on the double type.
CtTypeReference<Float>	TypeFactory.floatPrimitiveType()	Returns a reference on the float primitive type.
CtTypeReference<Float>	TypeFactory.floatType()	Returns a reference on the float type.
CtTypeReference	TypeFactory.getDefaultBoundingType()	Returns the default bounding type value
CtTypeReference<Integer>	TypeFactory.integerPrimitiveType()	Returns a reference on the integer primitive type.
CtTypeReference<Integer>	TypeFactory.integerType()	Returns a reference on the integer type.
CtTypeReference<Long>	TypeFactory.longPrimitiveType()	Returns a reference on the long primitive type.
CtTypeReference<Long>	TypeFactory.longType()	Returns a reference on the long type.
CtTypeReference<?>	TypeFactory.nullType()	Returns a reference on the null type (type of null).
CtTypeReference<Object>	TypeFactory.objectType()	Returns a reference on the object type.
CtTypeReference<Short>	TypeFactory.shortPrimitiveType()	Returns a reference on the short primitive type.
CtTypeReference<Short>	TypeFactory.shortType()	Returns a reference on the short type.
CtTypeReference<String>	TypeFactory.stringType()	Returns a reference on the string type.
CtTypeReference<Void>	TypeFactory.voidPrimitiveType()	Returns a reference on the void primitive type.
CtTypeReference<Void>	TypeFactory.voidType()	Returns a reference on the void type.

Methods in spoon.reflect.factory that return types with arguments of type CtTypeReference

Modifier and Type	Method	Description
List<CtTypeReference<?>>	Factory.createReferences(List<Class<?>> classes)
List<CtTypeReference<?>>	FactoryImpl.createReferences(List<Class<?>> classes)
List<CtTypeReference<?>>	TypeFactory.createReferences(List<Class<?>> classes)	Creates a collection of type references from a collection of classes.

Methods in spoon.reflect.factory with parameters of type CtTypeReference

Modifier and Type	Method	Description
<A extends Annotation> CtAnnotation<A>	AnnotationFactory.annotate(CtElement element, CtTypeReference<A> annotationType)	Adds an annotation to an element.
<A extends Annotation> CtAnnotation<A>	AnnotationFactory.annotate(CtElement element, CtTypeReference<A> annotationType, String annotationElementName, Object value)	Creates/updates an element's annotation value.
<T> CtField<T>	FieldFactory.create(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference<T> type, String name)	Creates a field.
<T> CtField<T>	FieldFactory.create(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)	Creates a field.
<R, B extends R> CtMethod<R>	MethodFactory.create(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference<R> returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock<B> body)	Creates a method.
<T> CtMethod<T>	MethodFactory.create(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference<T> returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)	Creates an empty method.
<A extends Annotation> CtAnnotation<A>	CodeFactory.createAnnotation(CtTypeReference<A> annotationType)	Creates an annotation.
<A extends Annotation> CtAnnotation<A>	Factory.createAnnotation(CtTypeReference<A> annotationType)
<A extends Annotation> CtAnnotation<A>	FactoryImpl.createAnnotation(CtTypeReference<A> annotationType)
CtArrayTypeReference<?>	Factory.createArrayReference(CtTypeReference<?> reference, int n)
<T> CtArrayTypeReference<T[]>	Factory.createArrayReference(CtTypeReference<T> reference)
CtArrayTypeReference<?>	FactoryImpl.createArrayReference(CtTypeReference<?> reference, int n)
<T> CtArrayTypeReference<T[]>	FactoryImpl.createArrayReference(CtTypeReference<T> reference)
CtArrayTypeReference<?>	TypeFactory.createArrayReference(CtTypeReference<?> reference, int n)	Creates a reference to a n-dimension array of given type.
<T> CtArrayTypeReference<T[]>	TypeFactory.createArrayReference(CtTypeReference<T> reference)	Creates a reference to a one-dimension array of given type.
<T> CtCatchVariable<T>	CodeFactory.createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds)	Creates a catch variable declaration.
<T> CtCatchVariable<T>	Factory.createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds)
<T> CtCatchVariable<T>	FactoryImpl.createCatchVariable(CtTypeReference<T> type, String name, ModifierKind... modifierKinds)
<T> CtFieldAccess<Class<T>>	CodeFactory.createClassAccess(CtTypeReference<T> type)	Creates a class access expression of the form C.class.
<T> CtFieldAccess<Class<T>>	Factory.createClassAccess(CtTypeReference<T> type)
<T> CtFieldAccess<Class<T>>	FactoryImpl.createClassAccess(CtTypeReference<T> type)
<T> CtConstructorCall<T>	CodeFactory.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)	Creates a constructor call.
<T> CtConstructorCall<T>	Factory.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
<T> CtConstructorCall<T>	FactoryImpl.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
<T> CtField<T>	CodeFactory.createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities)	Creates a field.
<T> CtField<T>	Factory.createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities)
<T> CtField<T>	FactoryImpl.createCtField(String name, CtTypeReference<T> type, String exp, ModifierKind... visibilities)
CtField	Factory.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name)
CtField	Factory.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
CtField	FactoryImpl.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name)
CtField	FactoryImpl.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
<T> CtLocalVariable<T>	CodeFactory.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)	Creates a local variable declaration.
<T> CtLocalVariable<T>	Factory.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
<T> CtLocalVariable<T>	FactoryImpl.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
<T> CtLocalVariableReference<T>	CodeFactory.createLocalVariableReference(CtTypeReference<T> type, String name)	Creates a local variable reference with its name an type (weak referencing).
<T> CtLocalVariableReference<T>	Factory.createLocalVariableReference(CtTypeReference<T> type, String name)
<T> CtLocalVariableReference<T>	FactoryImpl.createLocalVariableReference(CtTypeReference<T> type, String name)
CtMethod	Factory.createMethod(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
CtMethod	Factory.createMethod(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
CtMethod	FactoryImpl.createMethod(CtClass<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes, CtBlock body)
CtMethod	FactoryImpl.createMethod(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference returnType, String name, List<CtParameter<?>> parameters, Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T> CtParameter<T>	ExecutableFactory.createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name)	Creates a new parameter.
<T> CtParameter<T>	Factory.createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name)
<T> CtParameter<T>	FactoryImpl.createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name)
CtProvidedService	Factory.createProvidedService(CtTypeReference ctTypeReference)
CtProvidedService	FactoryImpl.createProvidedService(CtTypeReference ctTypeReference)
CtProvidedService	ModuleFactory.createProvidedService(CtTypeReference typeReference)
<T> CtExecutableReference<T>	ConstructorFactory.createReference(CtTypeReference<T> type, CtExpression<?>... parameters)	Creates a constructor reference.
<T> CtExecutableReference<T>	ExecutableFactory.createReference(CtTypeReference<?> declaringType, boolean isStatic, CtTypeReference<T> type, String methodName, List<CtTypeReference<?>> parameterTypes)	Creates an executable reference.
<T> CtExecutableReference<T>	ExecutableFactory.createReference(CtTypeReference<?> declaringType, boolean isStatic, CtTypeReference<T> type, String methodName, CtTypeReference<?>... parameterTypes)	Creates an executable reference.
<T> CtExecutableReference<T>	ExecutableFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, String methodName, List<CtTypeReference<?>> parameterTypes)	Creates an executable reference.
<T> CtExecutableReference<T>	ExecutableFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, String methodName, CtTypeReference<?>... parameterTypes)	Creates an executable reference.
<T> CtFieldReference<T>	FieldFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, String fieldName)	Creates a field reference.
<T> CtThisAccess<T>	CodeFactory.createThisAccess(CtTypeReference<T> type)	Creates an explicit access to a this variable (of the form type.this).
<T> CtThisAccess<T>	CodeFactory.createThisAccess(CtTypeReference<T> type, boolean isImplicit)	Creates an access to a this variable (of the form type.this).
<T> CtThisAccess<T>	Factory.createThisAccess(CtTypeReference<T> type)
<T> CtThisAccess<T>	Factory.createThisAccess(CtTypeReference<T> type, boolean isImplicit)
<T> CtThisAccess<T>	FactoryImpl.createThisAccess(CtTypeReference<T> type)
<T> CtThisAccess<T>	FactoryImpl.createThisAccess(CtTypeReference<T> type, boolean isImplicit)
<T> CtTypeAccess<T>	CodeFactory.createTypeAccess(CtTypeReference<T> accessedType)	Creates a accessed type.
<T> CtTypeAccess<T>	CodeFactory.createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit)	Creates a accessed type.
<T> CtTypeAccess<T>	Factory.createTypeAccess(CtTypeReference<T> accessedType)
<T> CtTypeAccess<T>	Factory.createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit)
<T> CtTypeAccess<T>	FactoryImpl.createTypeAccess(CtTypeReference<T> accessedType)
<T> CtTypeAccess<T>	FactoryImpl.createTypeAccess(CtTypeReference<T> accessedType, boolean isImplicit)
<T> CtTypeAccess<T>	CodeFactory.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)	Creates a accessed type, see CodeFactory.createTypeAccess(CtTypeReference) for details.
<T> CtTypeAccess<T>	Factory.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)
<T> CtTypeAccess<T>	FactoryImpl.createTypeAccessWithoutCloningReference(CtTypeReference<T> accessedType)
CtTypeMemberWildcardImportReference	Factory.createTypeMemberWildcardImportReference(CtTypeReference<?> typeReference)
CtTypeMemberWildcardImportReference	FactoryImpl.createTypeMemberWildcardImportReference(CtTypeReference typeReference)
CtTypeMemberWildcardImportReference	TypeFactory.createTypeMemberWildcardImportReference(CtTypeReference typeReference)	Create a wildcard reference to a simple type
CtUsedService	Factory.createUsedService(CtTypeReference typeReference)
CtUsedService	FactoryImpl.createUsedService(CtTypeReference typeReference)
CtUsedService	ModuleFactory.createUsedService(CtTypeReference typeReference)

Method parameters in spoon.reflect.factory with type arguments of type CtTypeReference

Modifier and Type	Method	Description
<T> CtIntersectionTypeReference<T>	Factory.createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds)
<T> CtIntersectionTypeReference<T>	FactoryImpl.createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds)
<T> CtIntersectionTypeReference<T>	TypeFactory.createIntersectionTypeReferenceWithBounds(List<CtTypeReference<?>> bounds)	Creates an intersection type reference.
<T> CtExecutableReference<T>	ExecutableFactory.createReference(CtTypeReference<?> declaringType, boolean isStatic, CtTypeReference<T> type, String methodName, List<CtTypeReference<?>> parameterTypes)	Creates an executable reference.
<T> CtExecutableReference<T>	ExecutableFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, String methodName, List<CtTypeReference<?>> parameterTypes)	Creates an executable reference.

Uses of CtTypeReference in spoon.reflect.reference

Subinterfaces of CtTypeReference in spoon.reflect.reference

Modifier and Type	Interface	Description
interface	CtArrayTypeReference<T>	This interface defines a reference to an array.
interface	CtIntersectionTypeReference<T>	This interface defines a reference to an intersection type in generics or in casts.
interface	CtTypeParameterReference	This interface defines a reference to a type parameter (aka generics).
interface	CtWildcardReference	Represents a wildcard in generic type annotations, i.e.

Methods in spoon.reflect.reference with type parameters of type CtTypeReference

Modifier and Type	Method	Description
<C extends CtTypeReference<T>> C	CtTypeReference.setDeclaringType(CtTypeReference<?> type)	Sets the reference to the declaring type.
<C extends CtTypeReference<T>> C	CtTypeReference.setPackage(CtPackageReference pack)	Sets the reference to the declaring package.

Methods in spoon.reflect.reference that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<?>	CtTypeReference.box()	Returns the corresponding non-primitive type for a primitive type (the same type otherwise).
CtTypeReference<T>	CtTypeReference.clone()
CtTypeReference<?>	CtTypeReference.getAccessType()	Computes nearest access path parent to this type from the context of this type reference.
CtTypeReference<?>	CtArrayTypeReference.getArrayType()	Gets the type of the array elements at the finest grain.
CtTypeReference<?>	CtTypeParameterReference.getBoundingType()	A type parameter can have an extends clause which declare one (CtTypeReference or more (CtIntersectionTypeReference references.
CtTypeReference<?>	CtWildcardReference.getBoundingType()	A type parameter can have an extends clause which declare one (CtTypeReference or more (CtIntersectionTypeReference references.
CtTypeReference<?>	CtArrayTypeReference.getComponentType()	Gets the type of the elements contained in this array.
CtTypeReference<?>	CtExecutableReference.getDeclaringType()	Gets the reference to the type that declares this executable.
CtTypeReference<?>	CtFieldReference.getDeclaringType()	Gets the type in which the field is declared.
CtTypeReference<?>	CtTypeReference.getDeclaringType()	Gets the type that declares the referenced type.
CtTypeReference<?>	CtTypeReference.getSuperclass()
CtTypeReference<?>	CtTypeReference.getTopLevelType()	Returns this, or top level type of this, if this is an inner type
CtTypeReference<T>	CtExecutableReference.getType()	For methods, gets the return type of the executable (may be null in noclasspath mode).
CtTypeReference<T>	CtVariableReference.getType()	Gets the type of the variable.
CtTypeReference<?>	CtTypeMemberWildcardImportReference.getTypeReference()
CtTypeReference<T>	CtTypeReference.setSimplyQualified(boolean isSimplyQualified)
CtTypeReference<?>	CtTypeReference.unbox()	Returns the primitive type for a boxing type (unchanged if the type does not correspond to a boxing type).

Methods in spoon.reflect.reference that return types with arguments of type CtTypeReference

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtActualTypeContainer.getActualTypeArguments()	Gets the type arguments.
List<CtTypeReference<?>>	CtIntersectionTypeReference.getBounds()	Gets the bounds of the intersection type.
List<CtTypeReference<?>>	CtExecutableReference.getParameters()	Gets parameters of the executable.
Set<CtTypeReference<?>>	CtTypeReference.getSuperInterfaces()

Methods in spoon.reflect.reference with parameters of type CtTypeReference

Modifier and Type	Method	Description
<T extends CtActualTypeContainer> T	CtActualTypeContainer.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Adds a type argument.
<C extends CtIntersectionTypeReference> C	CtIntersectionTypeReference.addBound(CtTypeReference<?> bound)	Adds a bound.
boolean	CtTypeReference.canAccess(CtTypeReference<?> type)	Checks visibility based on public, protected, package protected and private modifiers of type
<S extends T> CtExecutableReference<S>	CtExecutableReference.getOverridingExecutable(CtTypeReference<?> subType)	Gets an overriding executable for this executable from a given subtype, if exists.
boolean	CtActualTypeContainer.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)	Removes a type argument.
boolean	CtIntersectionTypeReference.removeBound(CtTypeReference<?> bound)	Removes a bound.
<T extends CtWildcardReference> T	CtWildcardReference.setBoundingType(CtTypeReference<?> superType)	Sets the extends clause of the type parameter.
<C extends CtArrayTypeReference<T>> C	CtArrayTypeReference.setComponentType(CtTypeReference<?> componentType)	Sets the type of the elements contained in this array.
<C extends CtExecutableReference<T>> C	CtExecutableReference.setDeclaringType(CtTypeReference<?> declaringType)	Sets the declaring type.
<C extends CtFieldReference<T>> C	CtFieldReference.setDeclaringType(CtTypeReference<?> declaringType)	Sets the type in which the field is declared.
<C extends CtTypeReference<T>> C	CtTypeReference.setDeclaringType(CtTypeReference<?> type)	Sets the reference to the declaring type.
<C extends CtExecutableReference<T>> C	CtExecutableReference.setType(CtTypeReference type)	Sets the type of the variable.
<C extends CtVariableReference<T>> C	CtVariableReference.setType(CtTypeReference type)	Sets the type of the variable.
CtTypeMemberWildcardImportReference	CtTypeMemberWildcardImportReference.setTypeReference(CtTypeReference<?> typeReference)

Method parameters in spoon.reflect.reference with type arguments of type CtTypeReference

Modifier and Type	Method	Description
<T extends CtActualTypeContainer> T	CtActualTypeContainer.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)	Sets the type arguments.
<T extends CtActualTypeContainer> T	CtTypeParameterReference.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<C extends CtIntersectionTypeReference> C	CtIntersectionTypeReference.setBounds(List<CtTypeReference<?>> bounds)	Sets the bounds of the intersection type.
<C extends CtExecutableReference<T>> C	CtExecutableReference.setParameters(List<CtTypeReference<?>> parameters)	Sets parameters of the executable.

Uses of CtTypeReference in spoon.reflect.visitor

Fields in spoon.reflect.visitor declared as CtTypeReference

Modifier and Type	Field	Description
protected CtTypeReference<?>	ImportScannerImpl.targetType

Fields in spoon.reflect.visitor with type parameters of type CtTypeReference

Modifier and Type	Field	Description
protected Map<String,CtTypeReference<?>>	ImportScannerImpl.classImports

Methods in spoon.reflect.visitor that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<?>	PrintingContext.getCurrentTypeReference()

Methods in spoon.reflect.visitor with parameters of type CtTypeReference

Modifier and Type	Method	Description
protected boolean	ImportScannerImpl.addClassImport(CtTypeReference<?> ref)	Adds a type to the classImports.
protected boolean	ImportScannerImpl.classNamePresentInJavaLang(CtTypeReference<?> ref)
protected void	ForceFullyQualifiedProcessor.handleTypeReference(CtTypeReference<?> reference, LexicalScope nameScope, CtRole role)
protected void	ForceImportProcessor.handleTypeReference(CtTypeReference<?> reference, LexicalScope nameScope, CtRole role)
protected void	ImportCleaner.handleTypeReference(CtTypeReference<?> reference, ImportCleaner.Context context, CtRole role)
protected void	ImportConflictDetector.handleTypeReference(CtTypeReference<?> ref, LexicalScope nameScope, CtRole role)
protected boolean	ImportScannerImpl.isImportedInClassImports(CtTypeReference<?> ref)
boolean	PrintingContext.isInCurrentScope(CtTypeReference<?> typeRef)
protected boolean	ForceFullyQualifiedProcessor.isTypeReferenceToEnclosingType(LexicalScope nameScope, CtTypeReference<?> reference)
<T> void	CtAbstractVisitor.visitCtTypeReference(CtTypeReference<T> reference)
<T> void	CtBiScannerDefault.visitCtTypeReference(CtTypeReference<T> reference)
<T> void	CtInheritanceScanner.visitCtTypeReference(CtTypeReference<T> e)
<T> void	CtScanner.visitCtTypeReference(CtTypeReference<T> reference)
<T> void	CtVisitor.visitCtTypeReference(CtTypeReference<T> reference)	Visits a reference to a type.
<T> void	DefaultJavaPrettyPrinter.visitCtTypeReference(CtTypeReference<T> ref)
<T> void	ImportScannerImpl.visitCtTypeReference(CtTypeReference<T> reference)
<T> void	CtAbstractImportVisitor.visitTypeImport(CtTypeReference<T> typeReference)
<T> void	CtImportVisitor.visitTypeImport(CtTypeReference<T> typeReference)	Called for import like: import apackage.Type;

Uses of CtTypeReference in spoon.reflect.visitor.filter

Methods in spoon.reflect.visitor.filter with parameters of type CtTypeReference

Modifier and Type	Method	Description
protected void	SuperInheritanceHierarchyFunction.sendResult(CtTypeReference<?> typeRef, CtConsumer<Object> outputConsumer)
protected void	SuperInheritanceHierarchyFunction.visitSuperClasses(CtTypeReference<?> superTypeRef, CtConsumer<Object> outputConsumer, boolean includingInterfaces)	calls `outputConsumer.accept(superClass)` for all super classes of superType.
protected void	SuperInheritanceHierarchyFunction.visitSuperInterfaces(CtTypeReference<?> type, CtConsumer<Object> outputConsumer)	calls `outputConsumer.accept(interface)` for all superInterfaces of type recursively.

Constructors in spoon.reflect.visitor.filter with parameters of type CtTypeReference

Modifier	Constructor	Description
	LambdaFilter(CtTypeReference<?> iface)	Matches all lambdas implementing `iface` Use LambdaFilter.addImplementingInterface(CtTypeInformation) to define set of interfaces whose lambdas it is search for
	SubtypeFilter(CtTypeReference<?> superType)

Uses of CtTypeReference in spoon.support

Methods in spoon.support that return CtTypeReference

Modifier and Type	Method	Description
<T> CtTypeReference<T>	DefaultCoreFactory.createTypeReference()

Uses of CtTypeReference in spoon.support.adaption

Methods in spoon.support.adaption that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<?>	TypeAdaptor.adaptType(CtType<?> superType)	Adapts a type from a supertype to the context of this adaptor.
CtTypeReference<?>	TypeAdaptor.adaptType(CtTypeReference<?> superRef)	Adapts a type from a supertype to the context of this adaptor.

Methods in spoon.support.adaption with parameters of type CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<?>	TypeAdaptor.adaptType(CtTypeReference<?> superRef)	Adapts a type from a supertype to the context of this adaptor.
static boolean	TypeAdaptor.isSubtype(CtType<?> base, CtTypeReference<?> superRef)	Checks whether the base is a subtype of the passed superref.
boolean	TypeAdaptor.isSubtypeOf(CtTypeReference<?> superRef)	Checks if the context of this type adapter is a subtype of the passed superRef.

Constructors in spoon.support.adaption with parameters of type CtTypeReference

Modifier	Constructor	Description
	TypeAdaptor(CtTypeReference<?> hierarchyStart)	Creates a new type adaptor using the given reference as the start of its hierarchy.

Uses of CtTypeReference in spoon.support.compiler

Methods in spoon.support.compiler with parameters of type CtTypeReference

Modifier and Type	Method	Description
static CtStatement	SnippetCompilationHelper.compileStatement(CtCodeSnippetStatement st, CtTypeReference returnType)

Uses of CtTypeReference in spoon.support.compiler.jdt

Methods in spoon.support.compiler.jdt that return CtTypeReference

Modifier and Type	Method	Description
<T> CtTypeReference<T>	ReferenceBuilder.getTypeReference(String name)	Try to build a CtTypeReference from a simple name with specified generic types but returns null if the name doesn't correspond to a type (not start by an upper case).

Uses of CtTypeReference in spoon.support.reflect.code

Methods in spoon.support.reflect.code that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<A>	CtTypeAccessImpl.getAccessedType()
CtTypeReference<T>	CtAssignmentImpl.getType()
CtTypeReference<T>	CtCatchVariableImpl.getType()
CtTypeReference<T>	CtConstructorCallImpl.getType()
CtTypeReference<T>	CtExpressionImpl.getType()
CtTypeReference<T>	CtInvocationImpl.getType()
CtTypeReference<T>	CtLocalVariableImpl.getType()
CtTypeReference<Void>	CtTypeAccessImpl.getType()
CtTypeReference<T>	CtVariableAccessImpl.getType()

Methods in spoon.support.reflect.code that return types with arguments of type CtTypeReference

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtConstructorCallImpl.getActualTypeArguments()
List<CtTypeReference<?>>	CtInvocationImpl.getActualTypeArguments()
List<CtTypeReference<?>>	CtCatchVariableImpl.getMultiTypes()
Set<CtTypeReference<? extends Throwable>>	CtLambdaImpl.getThrownTypes()
List<CtTypeReference<?>>	CtAssignmentImpl.getTypeCasts()
List<CtTypeReference<?>>	CtExpressionImpl.getTypeCasts()

Methods in spoon.support.reflect.code with parameters of type CtTypeReference

Modifier and Type	Method	Description
<T extends CtActualTypeContainer> T	CtConstructorCallImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<T extends CtActualTypeContainer> T	CtInvocationImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<T extends CtMultiTypedElement> T	CtCatchVariableImpl.addMultiType(CtTypeReference<?> type)
<C extends CtExecutable<T>> C	CtLambdaImpl.addThrownType(CtTypeReference<? extends Throwable> throwType)
<C extends CtExpression<T>> C	CtAssignmentImpl.addTypeCast(CtTypeReference<?> type)
<C extends CtExpression<T>> C	CtExpressionImpl.addTypeCast(CtTypeReference<?> type)
boolean	CtConstructorCallImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean	CtInvocationImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean	CtCatchVariableImpl.removeMultiType(CtTypeReference<?> ref)
boolean	CtLambdaImpl.removeThrownType(CtTypeReference<? extends Throwable> throwType)
<C extends CtTypeAccess<A>> C	CtTypeAccessImpl.setAccessedType(CtTypeReference<A> accessedType)
<C extends CtTypedElement> C	CtAssignmentImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtCatchVariableImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtConstructorCallImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtExpressionImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtInvocationImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtLambdaImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtLocalVariableImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtTypeAccessImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtVariableAccessImpl.setType(CtTypeReference type)

Method parameters in spoon.support.reflect.code with type arguments of type CtTypeReference

Modifier and Type	Method	Description
<T extends CtActualTypeContainer> T	CtConstructorCallImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<T extends CtActualTypeContainer> T	CtInvocationImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<T extends CtMultiTypedElement> T	CtCatchVariableImpl.setMultiTypes(List<CtTypeReference<?>> types)
<C extends CtExecutable<T>> C	CtLambdaImpl.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtExpression<T>> C	CtAssignmentImpl.setTypeCasts(List<CtTypeReference<?>> casts)
<C extends CtExpression<T>> C	CtExpressionImpl.setTypeCasts(List<CtTypeReference<?>> casts)

Uses of CtTypeReference in spoon.support.reflect.declaration

Methods in spoon.support.reflect.declaration that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<A>	CtAnnotationImpl.getAnnotationType()
CtTypeReference<T>	CtTypeImpl.getReference()
CtTypeReference	CtProvidedServiceImpl.getServiceType()
CtTypeReference	CtUsedServiceImpl.getServiceType()
CtTypeReference<?>	CtAnnotationTypeImpl.getSuperclass()
CtTypeReference<?>	CtClassImpl.getSuperclass()
CtTypeReference<?>	CtEnumImpl.getSuperclass()
CtTypeReference<?>	CtRecordImpl.getSuperclass()
CtTypeReference<?>	CtTypeImpl.getSuperclass()
CtTypeReference<?>	CtTypeParameterImpl.getSuperclass()
CtTypeReference<Void>	CtAnonymousExecutableImpl.getType()
CtTypeReference<T>	CtConstructorImpl.getType()
CtTypeReference<T>	CtFieldImpl.getType()
CtTypeReference<T>	CtMethodImpl.getType()
CtTypeReference<T>	CtParameterImpl.getType()
CtTypeReference<Object>	CtRecordComponentImpl.getType()
CtTypeReference<T>	InvisibleArrayConstructorImpl.getType()
CtTypeReference<?>	CtTypeImpl.getTypeErasure()
CtTypeReference<?>	CtTypeParameterImpl.getTypeErasure()

Methods in spoon.support.reflect.declaration that return types with arguments of type CtTypeReference

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtCompilationUnitImpl.getDeclaredTypeReferences()
List<CtTypeReference>	CtProvidedServiceImpl.getImplementationTypes()
Set<CtTypeReference<?>>	CtClassImpl.getPermittedTypes()
Set<CtTypeReference<?>>	CtEnumImpl.getPermittedTypes()
Set<CtTypeReference<?>>	CtInterfaceImpl.getPermittedTypes()
Set<CtTypeReference<?>>	CtRecordImpl.getPermittedTypes()
Set<CtTypeReference<?>>	CtElementImpl.getReferencedTypes()
Set<CtTypeReference<?>>	CtAnnotationTypeImpl.getSuperInterfaces()
Set<CtTypeReference<?>>	CtTypeImpl.getSuperInterfaces()
Set<CtTypeReference<?>>	CtTypeParameterImpl.getSuperInterfaces()
Set<CtTypeReference<? extends Throwable>>	CtAnnotationMethodImpl.getThrownTypes()
Set<CtTypeReference<? extends Throwable>>	CtAnonymousExecutableImpl.getThrownTypes()
Set<CtTypeReference<? extends Throwable>>	CtExecutableImpl.getThrownTypes()
List<CtTypeReference<?>>	CtAnnotationImpl.getTypeCasts()
Set<CtTypeReference<?>>	CtTypeImpl.getUsedTypes(boolean includeSamePackage)

Methods in spoon.support.reflect.declaration with parameters of type CtTypeReference

Modifier and Type	Method	Description
CtCompilationUnitImpl	CtCompilationUnitImpl.addDeclaredTypeReference(CtTypeReference<?> type)
<T extends CtProvidedService> T	CtProvidedServiceImpl.addImplementationType(CtTypeReference usedType)
CtClass<T>	CtClassImpl.addPermittedType(CtTypeReference<?> type)
CtEnum<T>	CtEnumImpl.addPermittedType(CtTypeReference<?> type)
CtInterface<T>	CtInterfaceImpl.addPermittedType(CtTypeReference<?> type)
CtRecord	CtRecordImpl.addPermittedType(CtTypeReference<?> type)
<S, C extends CtType<T>> C	CtTypeImpl.addSuperInterface(CtTypeReference<S> interfac)
<S, C extends CtType<Object>> C	CtTypeParameterImpl.addSuperInterface(CtTypeReference<S> interfac)
CtExecutable	CtAnonymousExecutableImpl.addThrownType(CtTypeReference throwType)
<T extends CtExecutable<R>> T	CtExecutableImpl.addThrownType(CtTypeReference<? extends Throwable> throwType)
<A extends Annotation> CtAnnotation<A>	CtElementImpl.getAnnotation(CtTypeReference<A> annotationType)
CtConstructor<T>	CtClassImpl.getConstructor(CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>	CtEnumImpl.getMethod(String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>	CtEnumImpl.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>	CtTypeImpl.getMethod(String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>	CtTypeImpl.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>	CtTypeParameterImpl.getMethod(String name, CtTypeReference<?>... parameterTypes)
<R> CtMethod<R>	CtTypeParameterImpl.getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes)
Set<CtMethod<?>>	CtTypeImpl.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes)
Set<CtMethod<?>>	CtTypeParameterImpl.getMethodsAnnotatedWith(CtTypeReference<?>... annotationTypes)
protected boolean	CtTypeImpl.hasSameParameters(CtExecutable<?> candidate, CtTypeReference<?>... parameterTypes)
boolean	CtAnnotationTypeImpl.isSubtypeOf(CtTypeReference<?> type)
boolean	CtClassImpl.isSubtypeOf(CtTypeReference<?> type)
boolean	CtEnumImpl.isSubtypeOf(CtTypeReference<?> type)
boolean	CtInterfaceImpl.isSubtypeOf(CtTypeReference<?> type)
boolean	CtTypeParameterImpl.isSubtypeOf(CtTypeReference<?> superTypeRef)
CtClass<T>	CtClassImpl.removePermittedType(CtTypeReference<?> type)
CtEnum<T>	CtEnumImpl.removePermittedType(CtTypeReference<?> type)
CtInterface<T>	CtInterfaceImpl.removePermittedType(CtTypeReference<?> type)
CtRecord	CtRecordImpl.removePermittedType(CtTypeReference<?> type)
<S> boolean	CtTypeImpl.removeSuperInterface(CtTypeReference<S> interfac)
<S> boolean	CtTypeParameterImpl.removeSuperInterface(CtTypeReference<S> interfac)
boolean	CtAnonymousExecutableImpl.removeThrownType(CtTypeReference throwType)
boolean	CtExecutableImpl.removeThrownType(CtTypeReference<? extends Throwable> throwType)
<T extends CtAnnotation<A>> T	CtAnnotationImpl.setAnnotationType(CtTypeReference<? extends Annotation> annotationType)
<T extends CtProvidedService> T	CtProvidedServiceImpl.setServiceType(CtTypeReference providingType)
<T extends CtUsedService> T	CtUsedServiceImpl.setServiceType(CtTypeReference usedService)
<C extends CtType<T>> C	CtAnnotationTypeImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtClassImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtEnumImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtInterfaceImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<Object>> C	CtRecordImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtTypeImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<Object>> C	CtTypeParameterImpl.setSuperclass(CtTypeReference<?> superClass)
<C extends CtTypedElement> C	CtAnonymousExecutableImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtConstructorImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtFieldImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtMethodImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtParameterImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	CtRecordComponentImpl.setType(CtTypeReference type)
<C extends CtTypedElement> C	InvisibleArrayConstructorImpl.setType(CtTypeReference type)

Method parameters in spoon.support.reflect.declaration with type arguments of type CtTypeReference

Modifier and Type	Method	Description
CtCompilationUnitImpl	CtCompilationUnitImpl.setDeclaredTypeReferences(List<CtTypeReference<?>> types)
<T extends CtProvidedService> T	CtProvidedServiceImpl.setImplementationTypes(List<CtTypeReference> usedTypes)
CtClass<T>	CtClassImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtEnum<T>	CtEnumImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtInterface<T>	CtInterfaceImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
CtRecord	CtRecordImpl.setPermittedTypes(Collection<CtTypeReference<?>> permittedTypes)
<C extends CtType<T>> C	CtAnnotationTypeImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<T>> C	CtTypeImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<C extends CtType<Object>> C	CtTypeParameterImpl.setSuperInterfaces(Set<CtTypeReference<?>> interfaces)
<U extends CtExecutable<T>> U	CtAnnotationMethodImpl.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<T extends CtExecutable<R>> T	CtExecutableImpl.setThrownTypes(Set<CtTypeReference<? extends Throwable>> thrownTypes)
<C extends CtExpression<A>> C	CtAnnotationImpl.setTypeCasts(List<CtTypeReference<?>> casts)

Uses of CtTypeReference in spoon.support.reflect.reference

Classes in spoon.support.reflect.reference that implement CtTypeReference

Modifier and Type	Class	Description
class	CtArrayTypeReferenceImpl<T>
class	CtIntersectionTypeReferenceImpl<T>
class	CtTypeParameterReferenceImpl
class	CtTypeReferenceImpl<T>
class	CtWildcardReferenceImpl

Methods in spoon.support.reflect.reference with type parameters of type CtTypeReference

Modifier and Type	Method	Description
<C extends CtTypeReference<T>> C	CtTypeReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType)
<C extends CtTypeReference<T>> C	CtTypeReferenceImpl.setPackage(CtPackageReference pack)

Methods in spoon.support.reflect.reference that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<?>	CtTypeReferenceImpl.box()
CtTypeReference<T>	CtTypeReferenceImpl.clone()
CtTypeReference<?>	CtTypeReferenceImpl.getAccessType()
CtTypeReference<?>	CtArrayTypeReferenceImpl.getArrayType()
CtTypeReference<?>	CtTypeParameterReferenceImpl.getBoundingType()
CtTypeReference<?>	CtWildcardReferenceImpl.getBoundingType()
CtTypeReference<?>	CtArrayTypeReferenceImpl.getComponentType()
CtTypeReference<?>	CtExecutableReferenceImpl.getDeclaringType()
CtTypeReference<?>	CtFieldReferenceImpl.getDeclaringType()
CtTypeReference<?>	CtTypeReferenceImpl.getDeclaringType()
CtTypeReference<?>	CtTypeReferenceImpl.getSuperclass()
CtTypeReference<?>	CtTypeReferenceImpl.getTopLevelType()
CtTypeReference<T>	CtExecutableReferenceImpl.getType()
CtTypeReference<T>	CtVariableReferenceImpl.getType()
CtTypeReference<?>	CtArrayTypeReferenceImpl.getTypeErasure()
CtTypeReference<?>	CtIntersectionTypeReferenceImpl.getTypeErasure()
CtTypeReference<?>	CtTypeParameterReferenceImpl.getTypeErasure()
CtTypeReference<?>	CtTypeReferenceImpl.getTypeErasure()
CtTypeReference<?>	CtTypeMemberWildcardImportReferenceImpl.getTypeReference()
CtTypeReference<?>	CtTypeReferenceImpl.unbox()

Methods in spoon.support.reflect.reference that return types with arguments of type CtTypeReference

Modifier and Type	Method	Description
List<CtTypeReference<?>>	CtExecutableReferenceImpl.getActualTypeArguments()
List<CtTypeReference<?>>	CtTypeParameterReferenceImpl.getActualTypeArguments()
List<CtTypeReference<?>>	CtTypeReferenceImpl.getActualTypeArguments()
List<CtTypeReference<?>>	CtIntersectionTypeReferenceImpl.getBounds()
List<CtTypeReference<?>>	CtExecutableReferenceImpl.getParameters()
Set<CtTypeReference<?>>	CtTypeReferenceImpl.getSuperInterfaces()

Methods in spoon.support.reflect.reference with parameters of type CtTypeReference

Modifier and Type	Method	Description
<C extends CtActualTypeContainer> C	CtExecutableReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<C extends CtActualTypeContainer> C	CtTypeParameterReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<C extends CtActualTypeContainer> C	CtTypeReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<C extends CtIntersectionTypeReference> C	CtIntersectionTypeReferenceImpl.addBound(CtTypeReference<?> bound)
boolean	CtTypeReferenceImpl.canAccess(CtTypeReference<?> type)
<S extends T> CtExecutableReference<S>	CtExecutableReferenceImpl.getOverridingExecutable(CtTypeReference<?> subType)
boolean	CtTypeParameterReferenceImpl.isSubtypeOf(CtTypeReference<?> type)
boolean	CtTypeReferenceImpl.isSubtypeOf(CtTypeReference<?> type)
boolean	CtExecutableReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean	CtTypeParameterReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean	CtTypeReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean	CtIntersectionTypeReferenceImpl.removeBound(CtTypeReference<?> bound)
<T extends CtWildcardReference> T	CtWildcardReferenceImpl.setBoundingType(CtTypeReference<?> superType)
<C extends CtArrayTypeReference<T>> C	CtArrayTypeReferenceImpl.setComponentType(CtTypeReference<?> componentType)
<C extends CtExecutableReference<T>> C	CtExecutableReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType)
<C extends CtFieldReference<T>> C	CtFieldReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType)
<C extends CtTypeReference<T>> C	CtTypeReferenceImpl.setDeclaringType(CtTypeReference<?> declaringType)
<C extends CtExecutableReference<T>> C	CtExecutableReferenceImpl.setType(CtTypeReference type)
<C extends CtVariableReference<T>> C	CtVariableReferenceImpl.setType(CtTypeReference type)
CtTypeMemberWildcardImportReferenceImpl	CtTypeMemberWildcardImportReferenceImpl.setTypeReference(CtTypeReference<?> typeReference)

Method parameters in spoon.support.reflect.reference with type arguments of type CtTypeReference

Modifier and Type	Method	Description
<C extends CtActualTypeContainer> C	CtExecutableReferenceImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<C extends CtActualTypeContainer> C	CtTypeParameterReferenceImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<C extends CtActualTypeContainer> C	CtTypeReferenceImpl.setActualTypeArguments(List<? extends CtTypeReference<?>> actualTypeArguments)
<C extends CtIntersectionTypeReference> C	CtIntersectionTypeReferenceImpl.setBounds(List<CtTypeReference<?>> bounds)
<C extends CtExecutableReference<T>> C	CtExecutableReferenceImpl.setParameters(List<CtTypeReference<?>> parameters)

Uses of CtTypeReference in spoon.support.visitor

Methods in spoon.support.visitor that return CtTypeReference

Modifier and Type	Method	Description
CtTypeReference<?>	GenericTypeAdapter.adaptType(CtTypeInformation type)	adapts `type` to the CtTypeReference of the scope of this GenericTypeAdapter This mapping function is able to resolve CtTypeParameter of: A) input type or any super class or any enclosing class of input type or it's super class B) super interfaces of input type or super interfaces of it's super classes. The type reference is adapted recursive including all it's actual type arguments and bounds.
protected CtTypeReference<?>	ClassTypingContext.adaptTypeParameter(CtTypeParameter typeParam)	adapts `typeParam` to the CtTypeReference of scope of this ClassTypingContext In can be CtTypeParameterReference again - depending actual type arguments of this ClassTypingContext.
protected CtTypeReference<?>	MethodTypingContext.adaptTypeParameter(CtTypeParameter typeParam)	Adapts `typeParam` to the CtTypeReference of scope of this MethodTypingContext In can be CtTypeParameterReference again - depending actual type arguments of this MethodTypingContext.

Methods in spoon.support.visitor that return types with arguments of type CtTypeReference

Modifier and Type	Method	Description
Set<CtTypeReference<?>>	TypeReferenceScanner.getReferences()	Returns the set of calculated references.
List<CtTypeReference<?>>	ClassTypingContext.resolveActualTypeArgumentsOf(CtTypeReference<?> typeRef)	resolve actual type argument values of the provided type reference

Methods in spoon.support.visitor with parameters of type CtTypeReference

Modifier and Type	Method	Description
protected ClassTypingContext	ClassTypingContext.createEnclosingHierarchy(CtTypeReference<?> enclosingTypeRef)	might be used to create custom chain of super type hierarchies
boolean	ClassTypingContext.isSubtypeOf(CtTypeReference<?> superTypeRef)	detects if `superTypeRef` is a super type of the type or type reference, which was send to constructor of this instance.
List<CtTypeReference<?>>	ClassTypingContext.resolveActualTypeArgumentsOf(CtTypeReference<?> typeRef)	resolve actual type argument values of the provided type reference
<T> void	SignaturePrinter.visitCtTypeReference(CtTypeReference<T> reference)
<T> void	TypeReferenceScanner.visitCtTypeReference(CtTypeReference<T> reference)

Constructors in spoon.support.visitor with parameters of type CtTypeReference

Modifier	Constructor	Description
	ClassTypingContext(CtTypeReference<?> typeReference)

Constructor parameters in spoon.support.visitor with type arguments of type CtTypeReference

Modifier	Constructor	Description
	TypeReferenceScanner(HashSet<CtTypeReference<?>> references)	Constructor.

Uses of CtTypeReference in spoon.support.visitor.clone

Methods in spoon.support.visitor.clone with parameters of type CtTypeReference

Modifier and Type	Method	Description
<T> void	CloneBuilder.visitCtTypeReference(CtTypeReference<T> e)
<T> void	CloneVisitor.visitCtTypeReference(CtTypeReference<T> reference)

Uses of CtTypeReference in spoon.support.visitor.java.internal

Methods in spoon.support.visitor.java.internal with parameters of type CtTypeReference

Modifier and Type	Method	Description
void	AnnotationRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void	ExecutableRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void	RecordComponentRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
void	RuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
void	TypeReferenceRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
void	TypeRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void	VariableRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)

Constructors in spoon.support.visitor.java.internal with parameters of type CtTypeReference

Modifier	Constructor	Description
	TypeReferenceRuntimeBuilderContext(Type type, CtTypeReference<?> typeReference)

Uses of CtTypeReference in spoon.support.visitor.replace

Methods in spoon.support.visitor.replace with parameters of type CtTypeReference

Modifier and Type	Method	Description
<T> void	ReplacementVisitor.visitCtTypeReference(CtTypeReference<T> reference)

Uses of CtTypeReference in spoon.template

Methods in spoon.template with parameters of type CtTypeReference

Modifier and Type	Method	Description
static void	Substitution.redirectTypeReferences(CtElement element, CtTypeReference<?> source, CtTypeReference<?> target)	A helper method that recursively redirects all the type references from a source type to a target type in the given element.
static CtBlock<?>	Substitution.substituteMethodBody(CtClass<?> targetClass, Template<?> template, String executableName, CtTypeReference<?>... parameterTypes)	Gets a body from a template executable with all the template parameters substituted.
static CtStatement	Substitution.substituteStatement(CtClass<?> targetClass, Template<?> template, int statementIndex, String executableName, CtTypeReference<?>... parameterTypes)	Gets a statement from a template executable with all the template parameters substituted.