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.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 and 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 and 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 and Description
CtTypeReference<A>	CtTypeAccess.getAccessedType() Returns type represented and contained in the type access.
CtTypeReference<T>	CtVariableAccess.getType()
CtTypeReference<T>	CtConstructorCall.getType()
CtTypeReference<T>	CtSuperAccess.getType()
CtTypeReference<java.lang.Void>	CtTypeAccess.getType() Returns always VOID.
CtTypeReference<T>	CtInvocation.getType() Return the type returned by the invocation.
CtTypeReference<T>	CtCatchVariable.getType() Returns type reference of the exception variable in a catch.

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

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

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

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

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

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

Uses of CtTypeReference in spoon.reflect.declaration

Methods in spoon.reflect.declaration that return CtTypeReference

Modifier and Type	Method and Description
CtTypeReference<A>	CtAnnotation.getAnnotationType() Returns the annotation type of this annotation.
CtTypeReference<T>	CtType.getReference() Returns the corresponding type reference.
CtTypeReference	CtUsedService.getServiceType()
CtTypeReference	CtProvidedService.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 and Description
java.util.List<CtTypeReference<?>>	CtCompilationUnit.getDeclaredTypeReferences() Gets references to all the types declared in this compilation unit.
java.util.List<CtTypeReference>	CtProvidedService.getImplementationTypes()
java.util.List<CtTypeReference<?>>	CtMultiTypedElement.getMultiTypes() Gets all types of the element.
java.util.Set<CtTypeReference<?>>	CtElement.getReferencedTypes() Calculates and returns the set of all the types referenced by this element (and sub-elements in the AST).
java.util.Set<CtTypeReference<?>>	CtTypeInformation.getSuperInterfaces() Returns the interface types directly implemented by this class or extended by this interface.
java.util.Set<CtTypeReference<? extends java.lang.Throwable>>	CtExecutable.getThrownTypes() Returns the exceptions and other throwables listed in this method or constructor's throws clause.
java.util.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 and 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.
<S,C extends CtType<java.lang.Object>> C	CtTypeParameter.addSuperInterface(CtTypeReference<S> interfac)
<S,C extends CtType<T>> C	CtType.addSuperInterface(CtTypeReference<S> interfac)
<T extends CtExecutable<java.lang.Void>> T	CtAnonymousExecutable.addThrownType(CtTypeReference<? extends java.lang.Throwable> throwType)
<T extends CtExecutable<R>> T	CtExecutable.addThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) add a thrown type.
<A extends java.lang.annotation.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(CtTypeReference<R> returnType, java.lang.String name, CtTypeReference<?>... parameterTypes) Gets a method from its return type, name, and parameter types.
<R> CtMethod<R>	CtType.getMethod(CtTypeReference<R> returnType, java.lang.String name, CtTypeReference<?>... parameterTypes) Gets a method from its return type, name, and parameter types.
<R> CtMethod<R>	CtType.getMethod(java.lang.String name, CtTypeReference<?>... parameterTypes) Gets a method from its name and parameter types.
java.util.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.
<S> boolean	CtType.removeSuperInterface(CtTypeReference<S> interfac)
boolean	CtExecutable.removeThrownType(CtTypeReference<? extends java.lang.Throwable> throwType) remove a thrown type.
<T extends CtAnnotation<A>> T	CtAnnotation.setAnnotationType(CtTypeReference<? extends java.lang.annotation.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	CtType.setSuperclass(CtTypeReference<?> superClass) Sets the superclass type.
<C extends CtType<T>> C	CtEnum.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtAnnotationType.setSuperclass(CtTypeReference<?> superClass)
<C extends CtType<T>> C	CtInterface.setSuperclass(CtTypeReference<?> superClass)
<C extends CtTypedElement> C	CtTypedElement.setType(CtTypeReference<T> type) Sets this element's type.
<C extends CtTypedElement> C	CtConstructor.setType(CtTypeReference<T> type)
<C extends CtTypedElement> C	CtAnonymousExecutable.setType(CtTypeReference<java.lang.Void> type)

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

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

Uses of CtTypeReference in spoon.reflect.factory

Fields in spoon.reflect.factory declared as CtTypeReference

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

Methods in spoon.reflect.factory that return CtTypeReference

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

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

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

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

Modifier and Type	Method and Description
<R,B extends R> CtMethod<R>	MethodFactory.create(CtClass<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference<R> returnType, java.lang.String name, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes, CtBlock<B> body) Creates a method.
<T> CtConstructor<T>	ConstructorFactory.create(CtClass<T> target, java.util.Set<ModifierKind> modifiers, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) Creates an empty constructor.
<T> CtConstructor<T>	ConstructorFactory.create(CtClass<T> target, java.util.Set<ModifierKind> modifiers, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes, CtBlock<T> body) Creates a constructor.
<T> CtMethod<T>	MethodFactory.create(CtType<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference<T> returnType, java.lang.String name, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes) Creates an empty method.
CtConstructor	Factory.createConstructor(CtClass target, java.util.Set<ModifierKind> modifiers, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
CtConstructor	FactoryImpl.createConstructor(CtClass target, java.util.Set<ModifierKind> modifiers, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
CtConstructor	Factory.createConstructor(CtClass target, java.util.Set<ModifierKind> modifiers, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes, CtBlock body)
CtConstructor	FactoryImpl.createConstructor(CtClass target, java.util.Set<ModifierKind> modifiers, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes, CtBlock body)
<T> CtIntersectionTypeReference<T>	TypeFactory.createIntersectionTypeReferenceWithBounds(java.util.List<CtTypeReference<?>> bounds) Creates an intersection type reference.
<T> CtIntersectionTypeReference<T>	Factory.createIntersectionTypeReferenceWithBounds(java.util.List<CtTypeReference<?>> bounds)
<T> CtIntersectionTypeReference<T>	FactoryImpl.createIntersectionTypeReferenceWithBounds(java.util.List<CtTypeReference<?>> bounds)
CtMethod	Factory.createMethod(CtClass<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference returnType, java.lang.String name, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes, CtBlock body)
CtMethod	FactoryImpl.createMethod(CtClass<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference returnType, java.lang.String name, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes, CtBlock body)
CtMethod	Factory.createMethod(CtType<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference returnType, java.lang.String name, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
CtMethod	FactoryImpl.createMethod(CtType<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference returnType, java.lang.String name, java.util.List<CtParameter<?>> parameters, java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
<T> CtExecutableReference<T>	ExecutableFactory.createReference(CtTypeReference<?> declaringType, boolean isStatic, CtTypeReference<T> type, java.lang.String methodName, java.util.List<CtTypeReference<?>> parameterTypes) Creates an executable reference.
<T> CtExecutableReference<T>	ExecutableFactory.createReference(CtTypeReference<?> declaringType, CtTypeReference<T> type, java.lang.String methodName, java.util.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 and 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 and 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 and 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<?>	CtFieldReference.getDeclaringType() Gets the type in which the field is declared.
CtTypeReference<?>	CtExecutableReference.getDeclaringType() Gets the reference to the type that declares this executable.
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 and Description
java.util.List<CtTypeReference<?>>	CtActualTypeContainer.getActualTypeArguments() Gets the type arguments.
java.util.List<CtTypeReference<?>>	CtIntersectionTypeReference.getBounds() Gets the bounds of the intersection type.
java.util.List<CtTypeReference<?>>	CtExecutableReference.getParameters() Gets parameters of the executable.
java.util.Set<CtTypeReference<?>>	CtTypeReference.getSuperInterfaces()

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

Modifier and Type	Method and 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<T> type) Sets the type of the variable.
<C extends CtVariableReference<T>> C	CtVariableReference.setType(CtTypeReference<T> 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 and Description
<T extends CtActualTypeContainer> T	CtTypeParameterReference.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments)
<T extends CtActualTypeContainer> T	CtActualTypeContainer.setActualTypeArguments(java.util.List<? extends CtTypeReference<?>> actualTypeArguments) Sets the type arguments.
<C extends CtIntersectionTypeReference> C	CtIntersectionTypeReference.setBounds(java.util.List<CtTypeReference<?>> bounds) Sets the bounds of the intersection type.
<C extends CtExecutableReference<T>> C	CtExecutableReference.setParameters(java.util.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 and Description
protected CtTypeReference<?>	ImportScannerImpl.targetType

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

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

Methods in spoon.reflect.visitor that return CtTypeReference

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

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

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

Uses of CtTypeReference in spoon.reflect.visitor.filter

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

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

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

Constructor and 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 and Description
<T> CtTypeReference<T>	DefaultCoreFactory.createTypeReference()

Uses of CtTypeReference in spoon.support.compiler

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

Modifier and Type	Method and 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 and Description
<T> CtTypeReference<T>	ReferenceBuilder.getTypeReference(java.lang.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 and Description
CtTypeReference<A>	CtTypeAccessImpl.getAccessedType()
CtTypeReference<T>	CtAssignmentImpl.getType()
CtTypeReference<T>	CtExpressionImpl.getType()
CtTypeReference<T>	CtCatchVariableImpl.getType()
CtTypeReference<T>	CtVariableAccessImpl.getType()
CtTypeReference<T>	CtConstructorCallImpl.getType()
CtTypeReference<T>	CtLocalVariableImpl.getType()
CtTypeReference<java.lang.Void>	CtTypeAccessImpl.getType()
CtTypeReference<T>	CtInvocationImpl.getType()

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

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

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

Modifier and Type	Method and 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 java.lang.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 java.lang.Throwable> throwType)
<C extends CtTypeAccess<A>> C	CtTypeAccessImpl.setAccessedType(CtTypeReference<A> accessedType)
<C extends CtTypedElement> C	CtAssignmentImpl.setType(CtTypeReference<T> type)
<C extends CtTypedElement> C	CtExpressionImpl.setType(CtTypeReference<T> type)
<C extends CtTypedElement> C	CtCatchVariableImpl.setType(CtTypeReference<T> type)
<C extends CtTypedElement> C	CtVariableAccessImpl.setType(CtTypeReference<T> type)
<C extends CtTypedElement> C	CtConstructorCallImpl.setType(CtTypeReference<T> type)
<C extends CtTypedElement> C	CtLocalVariableImpl.setType(CtTypeReference<T> type)
<C extends CtTypedElement> C	CtInvocationImpl.setType(CtTypeReference<T> type)
<C extends CtTypedElement> C	CtTypeAccessImpl.setType(CtTypeReference<java.lang.Void> type)

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

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

Uses of CtTypeReference in spoon.support.reflect.declaration

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

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

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

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

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

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

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

Modifier and Type	Method and Description
CtCompilationUnitImpl	CtCompilationUnitImpl.setDeclaredTypeReferences(java.util.List<CtTypeReference<?>> types)
<T extends CtProvidedService> T	CtProvidedServiceImpl.setImplementationTypes(java.util.List<CtTypeReference> usedTypes)
<C extends CtType<java.lang.Object>> C	CtTypeParameterImpl.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces)
<C extends CtType<T>> C	CtTypeImpl.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces)
<C extends CtType<T>> C	CtAnnotationTypeImpl.setSuperInterfaces(java.util.Set<CtTypeReference<?>> interfaces)
<T extends CtExecutable<R>> T	CtExecutableImpl.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
<U extends CtExecutable<T>> U	CtAnnotationMethodImpl.setThrownTypes(java.util.Set<CtTypeReference<? extends java.lang.Throwable>> thrownTypes)
<C extends CtExpression<A>> C	CtAnnotationImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts)

Uses of CtTypeReference in spoon.support.reflect.reference

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

Modifier and Type	Class and 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 and 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 and Description
CtTypeReference<?>	CtTypeReferenceImpl.box()
CtTypeReference<T>	CtTypeReferenceImpl.clone()
CtTypeReference<?>	CtTypeReferenceImpl.getAccessType()
CtTypeReference<?>	CtArrayTypeReferenceImpl.getArrayType()
CtTypeReference<?>	CtTypeParameterReferenceImpl.getBoundingType()
CtTypeReference<?>	CtWildcardReferenceImpl.getBoundingType()
CtTypeReference<?>	CtArrayTypeReferenceImpl.getComponentType()
CtTypeReference<?>	CtFieldReferenceImpl.getDeclaringType()
CtTypeReference<?>	CtTypeReferenceImpl.getDeclaringType()
CtTypeReference<?>	CtExecutableReferenceImpl.getDeclaringType()
CtTypeReference<?>	CtTypeReferenceImpl.getSuperclass()
CtTypeReference<?>	CtTypeReferenceImpl.getTopLevelType()
CtTypeReference<T>	CtExecutableReferenceImpl.getType()
CtTypeReference<T>	CtVariableReferenceImpl.getType()
CtTypeReference<?>	CtTypeReferenceImpl.getTypeErasure()
CtTypeReference<?>	CtArrayTypeReferenceImpl.getTypeErasure()
CtTypeReference<?>	CtTypeParameterReferenceImpl.getTypeErasure()
CtTypeReference<?>	CtIntersectionTypeReferenceImpl.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 and Description
java.util.List<CtTypeReference<?>>	CtTypeReferenceImpl.getActualTypeArguments()
java.util.List<CtTypeReference<?>>	CtExecutableReferenceImpl.getActualTypeArguments()
java.util.List<CtTypeReference<?>>	CtTypeParameterReferenceImpl.getActualTypeArguments()
java.util.List<CtTypeReference<?>>	CtIntersectionTypeReferenceImpl.getBounds()
java.util.List<CtTypeReference<?>>	CtExecutableReferenceImpl.getParameters()
java.util.Set<CtTypeReference<?>>	CtTypeReferenceImpl.getSuperInterfaces()

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

Modifier and Type	Method and Description
<C extends CtActualTypeContainer> C	CtTypeReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<C extends CtActualTypeContainer> C	CtExecutableReferenceImpl.addActualTypeArgument(CtTypeReference<?> actualTypeArgument)
<C extends CtActualTypeContainer> C	CtTypeParameterReferenceImpl.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	CtTypeReferenceImpl.isSubtypeOf(CtTypeReference<?> type)
boolean	CtTypeParameterReferenceImpl.isSubtypeOf(CtTypeReference<?> type)
boolean	CtTypeReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean	CtExecutableReferenceImpl.removeActualTypeArgument(CtTypeReference<?> actualTypeArgument)
boolean	CtTypeParameterReferenceImpl.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<T> type)
<C extends CtVariableReference<T>> C	CtVariableReferenceImpl.setType(CtTypeReference<T> type)
CtTypeMemberWildcardImportReferenceImpl	CtTypeMemberWildcardImportReferenceImpl.setTypeReference(CtTypeReference<?> typeReference)

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

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

Uses of CtTypeReference in spoon.support.visitor

Methods in spoon.support.visitor that return CtTypeReference

Modifier and Type	Method and 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 and Description
java.util.Set<CtTypeReference<?>>	TypeReferenceScanner.getReferences() Returns the set of calculated references.
java.util.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 and 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.
java.util.List<CtTypeReference<?>>	ClassTypingContext.resolveActualTypeArgumentsOf(CtTypeReference<?> typeRef) resolve actual type argument values of the provided type reference
<T> void	TypeReferenceScanner.visitCtTypeReference(CtTypeReference<T> reference)
<T> void	SignaturePrinter.visitCtTypeReference(CtTypeReference<T> reference)

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

Constructor and Description
ClassTypingContext(CtTypeReference<?> typeReference)

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

Constructor and Description
TypeReferenceScanner(java.util.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 and 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 and Description
void	ExecutableRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void	TypeRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void	VariableRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
void	TypeReferenceRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)
void	AnnotationRuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> typeReference)
void	RuntimeBuilderContext.addTypeReference(CtRole role, CtTypeReference<?> ctTypeReference)

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

Constructor and Description
TypeReferenceRuntimeBuilderContext(java.lang.reflect.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 and 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 and 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 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, java.lang.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, java.lang.String executableName, CtTypeReference<?>... parameterTypes) Gets a statement from a template executable with all the template parameters substituted.