Uses of Class
org.aspectj.weaver.ResolvedType

Packages that use ResolvedType

Package	Description
org.aspectj.weaver
org.aspectj.weaver.ast
org.aspectj.weaver.bcel
org.aspectj.weaver.internal.tools
org.aspectj.weaver.ltw
org.aspectj.weaver.model
org.aspectj.weaver.patterns
org.aspectj.weaver.reflect
org.aspectj.weaver.tools

Uses of ResolvedType in org.aspectj.weaver

Subclasses of ResolvedType in org.aspectj.weaver

Modifier and Type	Class	Description
class	ArrayReferenceType	Represents a resolved array type
class	BoundedReferenceType	A BoundedReferenceType is the result of a generics wildcard expression ? extends String, ? super Foo etc..
class	MissingResolvedTypeWithKnownSignature	When we try to resolve a type in the world that we require to be present, and then fail to find it, we return an instance of this class.
class	ReferenceType	A reference type represents some 'real' type, not a primitive, not an array - but a real type, for example java.util.List.
class	TypeVariableReferenceType	ReferenceType pointing to a type variable.

Fields in org.aspectj.weaver declared as ResolvedType

Modifier and Type	Field	Description
protected ResolvedType[]	ResolvedMemberImpl.annotationTypes
protected ResolvedType	ConcreteTypeMunger.aspectType
protected ResolvedType	Advice.concreteAspect
static final ResolvedType[]	ResolvedType.EMPTY_ARRAY
static final ResolvedType[]	ResolvedType.EMPTY_RESOLVED_TYPE_ARRAY
static final ResolvedType[][]	Member.NO_PARAMETER_ANNOTATION_TYPES
static final ResolvedType[]	ResolvedType.NONE
protected ResolvedType[][]	ResolvedMemberImpl.parameterAnnotationTypes
ResolvedType[]	ResolvedType.temporaryAnnotationTypes
protected final ResolvedType	AbstractAnnotationAJ.type

Methods in org.aspectj.weaver that return ResolvedType

Modifier and Type	Method	Description
ResolvedType	ResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)	Look up the actual occurence of a particular type in the hierarchy for 'this' type.
ResolvedType	CrosscuttingMembersSet.findAspectDeclaringParents(DeclareParents p)
ResolvedType	World.TypeMap.get(String key)	Lookup a type by its signature, always look in the real map before the expendable map
ResolvedType[]	AnnotatedElement.getAnnotationTypes()
ResolvedType[]	ArrayReferenceType.getAnnotationTypes()
ResolvedType[]	GeneratedReferenceTypeDelegate.getAnnotationTypes()
ResolvedType[]	JoinPointSignature.getAnnotationTypes()
ResolvedType[]	ReferenceType.getAnnotationTypes()
ResolvedType[]	ReferenceTypeDelegate.getAnnotationTypes()
ResolvedType[]	ResolvedMember.getAnnotationTypes()
ResolvedType[]	ResolvedMemberImpl.getAnnotationTypes()
ResolvedType[]	ResolvedType.getAnnotationTypes()
ResolvedType[]	Shadow.getArgumentTypesForArrayConstructionShadow()
ResolvedType	ConcreteTypeMunger.getAspectType()
ResolvedType	Advice.getConcreteAspect()
ResolvedType	Checker.getConcreteAspect()
ResolvedType	IntMap.getConcreteAspect()
abstract ResolvedType	ShadowMunger.getConcreteAspect()
ResolvedType	World.getCoreType(UnresolvedType tx)	Special resolution for "core" types like OBJECT.
final ResolvedType[]	ArrayReferenceType.getDeclaredInterfaces()
ResolvedType[]	BoundedReferenceType.getDeclaredInterfaces()
ResolvedType[]	GeneratedReferenceTypeDelegate.getDeclaredInterfaces()
ResolvedType[]	MissingResolvedTypeWithKnownSignature.getDeclaredInterfaces()
ResolvedType[]	ReferenceType.getDeclaredInterfaces()	Find out from the generic signature the true signature of any interfaces I implement.
ResolvedType[]	ReferenceTypeDelegate.getDeclaredInterfaces()
abstract ResolvedType[]	ResolvedType.getDeclaredInterfaces()
ResolvedType	NewParentTypeMunger.getDeclaringType()
ResolvedType	ResolvedType.getDeclaringType()	Returns a ResolvedType object representing the declaring type of this type, or null if this type does not represent a non-package-level-type.
ResolvedType	ShadowMunger.getDeclaringType()
ResolvedType	BindingScope.getEnclosingType()
ResolvedType	NewParentTypeMunger.getNewParent()
ResolvedType	GeneratedReferenceTypeDelegate.getOuterClass()
ResolvedType	ReferenceType.getOuterClass()
ResolvedType	ReferenceTypeDelegate.getOuterClass()
ResolvedType	ResolvedType.getOuterClass()
ResolvedType[][]	JoinPointSignature.getParameterAnnotationTypes()
ResolvedType[][]	ResolvedMember.getParameterAnnotationTypes()
ResolvedType[][]	ResolvedMemberImpl.getParameterAnnotationTypes()
ResolvedType	ResolvedType.getRawType()
ResolvedType	ResolvableTypeList.getResolved(int nameIndex)
ResolvedType	ArrayReferenceType.getResolvedComponentType()
ResolvedType	ResolvedType.getResolvedComponentType()
ResolvedType[]	ResolvedType.getResolvedTypeParameters()
final ResolvedType	ArrayReferenceType.getSuperclass()
ResolvedType	GeneratedReferenceTypeDelegate.getSuperclass()
ResolvedType	MissingResolvedTypeWithKnownSignature.getSuperclass()
ResolvedType	ReferenceType.getSuperclass()
ResolvedType	ReferenceTypeDelegate.getSuperclass()
abstract ResolvedType	ResolvedType.getSuperclass()
ResolvedType	ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
final ResolvedType	AbstractAnnotationAJ.getType()
ResolvedType	AnnotationAJ.getType()
static ResolvedType	ResolvedType.makeArray(ResolvedType type, int dim)
ResolvedType	Iterators.ResolvedTypeArrayIterator.next()
ResolvedType	ResolvedType.parameterizedWith(UnresolvedType[] typeParameters)
ResolvedType	World.TypeMap.put(String key, ResolvedType type)	Add a new type into the map, the key is the type signature.
ResolvedType	World.TypeMap.remove(String key)	Remove a type from the map
ResolvedType	TypeVariableReferenceType.resolve(World world)	resolve the type variable we are managing and then return this object.
ResolvedType	UnresolvedType.resolve(World world)	Returns a resolved version of this type according to a particular world.
ResolvedType	UnresolvedTypeVariableReferenceType.resolve(World world)
ResolvedType	World.resolve(String name)	Convenience method for finding a type by name and resolving it in one step.
ResolvedType	World.resolve(String name, boolean allowMissing)
ResolvedType	World.resolve(ResolvedType ty)	Some TypeFactory operations create resolved types directly, but these won't be in the typeMap - this resolution process puts them there.
ResolvedType	World.resolve(UnresolvedType ty)	Resolve a type that we require to be present in the world
ResolvedType[]	World.resolve(UnresolvedType[] types)	Convenience method for resolving an array of unresolved types in one hit.
ResolvedType	World.resolve(UnresolvedType ty, boolean allowMissing)	Resolve a type.
ResolvedType	World.resolve(UnresolvedType ty, ISourceLocation isl)	Attempt to resolve a type - the source location gives you some context in which resolution is taking place.
ResolvedType	World.resolveGenericTypeFor(UnresolvedType anUnresolvedType, boolean allowMissing)	Attempt to resolve a type that should be a generic type.

Methods in org.aspectj.weaver that return types with arguments of type ResolvedType

Modifier and Type	Method	Description
static Iterator<ResolvedType>	Iterators.array(ResolvedType[] o, boolean genericsAware)
Collection<ResolvedType>	JoinPointSignature.getDeclaringTypes(World world)
Collection<ResolvedType>	Member.getDeclaringTypes(World world)
Collection<ResolvedType>	MemberImpl.getDeclaringTypes(World world)
final Iterator<ResolvedType>	ResolvedType.getDirectSupertypes()	Returns an iterator through ResolvedType objects representing all the direct supertypes of this type.
Map<ResolvedType,Set<ResolvedType>>	World.getExclusionMap()
Map<ResolvedType,Set<ResolvedType>>	World.getExclusionMap()
Map<String,Reference<ResolvedType>>	World.getExpendable()
Map<String,Reference<ResolvedType>>	World.TypeMap.getExpendableMap()
Map<String,ResolvedType>	World.getFixed()
Iterator<ResolvedType>	ResolvedType.getHierarchy()	Return an iterator over the types in this types hierarchy - starting with this type first, then all superclasses up to Object and then all interfaces (starting with those 'nearest' this type).
Iterator<ResolvedType>	ResolvedType.getHierarchy(boolean wantGenerics, boolean wantDeclaredParents)	Return an iterator over the types in this types hierarchy - starting with this type first, then all superclasses up to Object and then all interfaces (starting with those 'nearest' this type).
List<ResolvedType>	ResolvedType.getHierarchyWithoutIterator(boolean includeITDs, boolean allowMissing, boolean genericsAware)	Return a list of the types in the hierarchy of this type, starting with this type.
Map<String,ResolvedType>	World.TypeMap.getMainMap()
Collection<ResolvedType>	Checker.getThrownExceptions()
abstract Collection<ResolvedType>	ShadowMunger.getThrownExceptions()

Methods in org.aspectj.weaver with parameters of type ResolvedType

Modifier and Type	Method	Description
void	CrosscuttingMembersSet.addAdviceLikeDeclares(ResolvedType aspectType)
void	CrosscuttingMembersSet.addFixedCrosscuttingMembers(ResolvedType aspectType)
boolean	CrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType)
boolean	CrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType, boolean inWeavingPhase)
void	ReferenceType.addParent(ResolvedType newParent)
void	ResolvedType.addParent(ResolvedType newParent)
boolean	BoundedReferenceType.alwaysMatches(ResolvedType aCandidateType)
static Iterator<ResolvedType>	Iterators.array(ResolvedType[] o, boolean genericsAware)
boolean	TypeVariable.canBeBoundTo(ResolvedType candidate)	answer true if the given type satisfies all of the bound constraints of this type variable.
boolean	BoundedReferenceType.canBeCoercedTo(ResolvedType aCandidateType)
boolean	ResolvedType.canBeSeenBy(ResolvedType from)
protected boolean	Shadow.checkCanThrow(ShadowMunger munger, ResolvedType resolvedTypeX)
boolean	ResolvedType.checkLegalOverride(ResolvedMember parent, ResolvedMember child, int transformerPosition, ResolvedType aspectType)
int	World.compareByPrecedence(ResolvedType aspect1, ResolvedType aspect2)	Same signature as org.aspectj.util.PartialOrder.PartialComparable.compareTo
int	World.compareByPrecedenceAndHierarchy(ResolvedType aspect1, ResolvedType aspect2)	compares by precedence with the additional rule that a super-aspect is sorted before its sub-aspects
protected void	World.completeBinaryType(ResolvedType ret)	Called when a type is resolved - enables its type hierarchy to be finished off before we proceed
ConcreteTypeMunger	IWeavingSupport.concreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
ShadowMunger	Advice.concretize(ResolvedType fromType, World world, PerClause clause)
ShadowMunger	Checker.concretize(ResolvedType theAspect, World world, PerClause clause)	Concretize this Checker by concretizing the pointcut
abstract ShadowMunger	ShadowMunger.concretize(ResolvedType fromType, World world, PerClause clause)
ConcreteTypeMunger	IWeavingSupport.createAccessForInlineMunger(ResolvedType inAspect)
Advice	IWeavingSupport.createAdviceMunger(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member signature, ResolvedType concreteAspect)
final Advice	World.createAdviceMunger(AdviceKind kind, Pointcut p, Member signature, int extraParameterFlags, IHasSourceLocation loc, ResolvedType declaringAspect)	Create an advice shadow munger for the given advice kind
Collection<ShadowMunger>	CustomMungerFactory.createCustomShadowMungers(ResolvedType aspectType)
Collection<ConcreteTypeMunger>	CustomMungerFactory.createCustomTypeMungers(ResolvedType aspectType)
static ReferenceType	TypeFactory.createParameterizedType(ResolvedType aBaseType, UnresolvedType[] someTypeParameters, World inAWorld)	Create a parameterized version of a generic type.
void	World.TypeMap.demote(ResolvedType type)
ResolvedType	ResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)	Look up the actual occurence of a particular type in the hierarchy for 'this' type.
ReferenceType	ReferenceType.findDerivativeType(ResolvedType[] typeParameters)	Look for a derivative type with the specified type parameters.
TypePattern	World.getAspectScope(ResolvedType declaringType)
ResolvedMember	MethodDelegateTypeMunger.getDelegate(ResolvedType targetType)
ResolvedMember	NewConstructorTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
ResolvedMember	NewFieldTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
ResolvedMember	NewMethodTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
ResolvedMember	PrivilegedAccessMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
ResolvedMember	ResolvedTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
Integer	World.getPrecedenceIfAny(ResolvedType aspect1, ResolvedType aspect2)
abstract Var	Shadow.getThisAspectInstanceVar(ResolvedType aspectType)
ResolvedType	ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
List<ConcreteTypeMunger>	WeaverStateInfo.getTypeMungers(ResolvedType onType)
boolean	World.hasUnsatisfiedDependency(ResolvedType aspectType)	Determine if the named aspect requires a particular type around in order to be useful.
static ResolvedMember	AjcMemberMaker.interConstructor(ResolvedType targetType, ResolvedMember constructor, UnresolvedType aspectType)
static Member	AjcMemberMaker.interfaceConstructor(ResolvedType resolvedTypeX)
static ResolvedMember	AjcMemberMaker.interFieldInterfaceGetter(ResolvedMember field, ResolvedType onType, UnresolvedType aspectType)	This instance method goes on the interface the field is declared onto as well as its top-most implementors
static ResolvedMember	AjcMemberMaker.interFieldInterfaceSetter(ResolvedMember field, ResolvedType onType, UnresolvedType aspectType)	This instance method goes on the interface the field is declared onto as well as its top-most implementors
boolean	WeaverStateInfo.isAspectAlreadyApplied(ResolvedType someAspect)
boolean	World.isAspectIncluded(ResolvedType aspectType)
final boolean	ArrayReferenceType.isAssignableFrom(ResolvedType o)
boolean	ArrayReferenceType.isAssignableFrom(ResolvedType o, boolean allowMissing)
boolean	MissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other)
boolean	MissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other, boolean allowMissing)
boolean	ReferenceType.isAssignableFrom(ResolvedType other)
boolean	ReferenceType.isAssignableFrom(ResolvedType other, boolean allowMissing)
abstract boolean	ResolvedType.isAssignableFrom(ResolvedType other)	Determines if the variables of this type could be assigned values of another type without casting.
abstract boolean	ResolvedType.isAssignableFrom(ResolvedType other, boolean allowMissing)
final boolean	ArrayReferenceType.isCoerceableFrom(ResolvedType o)
boolean	MissingResolvedTypeWithKnownSignature.isCoerceableFrom(ResolvedType other)
boolean	ReferenceType.isCoerceableFrom(ResolvedType o)
abstract boolean	ResolvedType.isCoerceableFrom(ResolvedType other)	Determines if values of another type could possibly be cast to this type.
final boolean	ResolvedType.isConvertableFrom(ResolvedType other)	Determines if variables of this type could be assigned values of another with lots of help.
protected boolean	World.isExpendable(ResolvedType type)	Reference types we don't intend to weave may be ejected from the cache if we need the space.
boolean	ResolvedType.isTopmostImplementor(ResolvedType interfaceType)
boolean	JoinPointSignature.isVisible(ResolvedType fromType)
boolean	ResolvedMember.isVisible(ResolvedType fromType)
boolean	ResolvedMemberImpl.isVisible(ResolvedType fromType)
static boolean	ResolvedType.isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType)
static ResolvedMember	AjcMemberMaker.itdAtDeclareParentsField(ResolvedType targetType, UnresolvedType itdType, UnresolvedType aspectType)
static ResolvedType	ResolvedType.makeArray(ResolvedType type, int dim)
Var	IWeavingSupport.makeCflowAccessVar(ResolvedType formalType, Member cflowField, int arrayIndex)
static Advice	Advice.makeCflowEntry(World world, Pointcut entry, boolean isBelow, Member stackField, int nFreeVars, List<ShadowMunger> innerCflowEntries, ResolvedType inAspect)
static Advice	Advice.makePerCflowEntry(World world, Pointcut entry, boolean isBelow, Member stackField, ResolvedType inAspect, List<ShadowMunger> innerCflowEntries)
ConcreteTypeMunger	IWeavingSupport.makePerClauseAspect(ResolvedType aspect, PerClause.Kind kind)	Register a munger for perclause @AJ aspect so that we add aspectOf(..) to them as needed
static Advice	Advice.makePerObjectEntry(World world, Pointcut entry, boolean isThis, ResolvedType inAspect)
static Advice	Advice.makePerTypeWithinEntry(World world, Pointcut p, ResolvedType inAspect)
static Advice	Advice.makeSoftener(World world, Pointcut entry, TypePattern exceptionType, ResolvedType inAspect, IHasSourceLocation loc)
boolean	ConcreteTypeMunger.matches(ResolvedType onType)
boolean	MethodDelegateTypeMunger.FieldHostTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)	Match based on given type pattern, only classes can be matched
boolean	MethodDelegateTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)	Match based on given type pattern, only classes can be matched
boolean	PerObjectInterfaceTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
boolean	PerTypeWithinTargetTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
boolean	ResolvedTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
boolean	ResolvedType.needsNoConversionFrom(ResolvedType o)
abstract ConcreteTypeMunger	ConcreteTypeMunger.parameterizedFor(ResolvedType targetType)	For an ITD made on a generic type that shares type variables with that target type, this method will tailor the ITD for a particular usage of the generic type - either in its raw or parameterized form.
ResolvedTypeMunger	NewConstructorTypeMunger.parameterizedFor(ResolvedType target)	see ResolvedTypeMunger.parameterizedFor(ResolvedType)
ResolvedTypeMunger	NewFieldTypeMunger.parameterizedFor(ResolvedType target)	see ResolvedTypeMunger.parameterizedFor(ResolvedType)
ResolvedTypeMunger	NewMethodTypeMunger.parameterizedFor(ResolvedType target)	see ResolvedTypeMunger.parameterizedFor(ResolvedType)
ResolvedTypeMunger	ResolvedTypeMunger.parameterizedFor(ResolvedType target)	Parameterizes a resolved type munger for a particular usage of its target type (this is used when the target type is generic and the ITD shares type variables with the target) see ConcreteTypeMunger.parameterizedFor
ConcreteTypeMunger	TemporaryTypeMunger.parameterizedFor(ResolvedType targetType)
ResolvedMemberImpl	JoinPointSignature.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
ResolvedMemberImpl	JoinPointSignature.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, List<String> aliases)
ResolvedMemberImpl	ResolvedMember.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
ResolvedMemberImpl	ResolvedMember.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, List<String> aliases)
ResolvedMemberImpl	ResolvedMemberImpl.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
ResolvedMemberImpl	ResolvedMemberImpl.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, List<String> aliases)	Return a resolvedmember in which all the type variables in the signature have been replaced with the given bindings.
ResolvedMemberImpl	ResolvedPointcutDefinition.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)	Called when asking a parameterized super-aspect for its pointcuts.
ShadowMunger	Checker.parameterizeWith(ResolvedType declaringType, Map<String,UnresolvedType> typeVariableMap)	Parameterize the Checker by parameterizing the pointcut
abstract ShadowMunger	ShadowMunger.parameterizeWith(ResolvedType declaringType, Map<String,UnresolvedType> typeVariableMap)
static ResolvedMember	AjcMemberMaker.perObjectField(UnresolvedType declaringType, ResolvedType aspectType)
static ResolvedMember	AjcMemberMaker.perTypeWithinField(UnresolvedType declaringType, ResolvedType aspectType)
static ResolvedMember	AjcMemberMaker.perTypeWithinWithinTypeField(UnresolvedType declaringType, ResolvedType aspectType)
ResolvedType	World.TypeMap.put(String key, ResolvedType type)	Add a new type into the map, the key is the type signature.
Advice	AjAttribute.AdviceAttribute.reify(Member signature, World world, ResolvedType concreteAspect)
PerClause	AjAttribute.Aspect.reify(ResolvedType inAspect)
ConcreteTypeMunger	AjAttribute.TypeMunger.reify(World world, ResolvedType aspectType)
PerClause	AjAttribute.Aspect.reifyFromAtAspectJ(ResolvedType inAspect)
ResolvedType	World.resolve(ResolvedType ty)	Some TypeFactory operations create resolved types directly, but these won't be in the typeMap - this resolution process puts them there.
void	JoinPointSignature.setAnnotationTypes(ResolvedType[] annotationtypes)
void	ResolvedMember.setAnnotationTypes(ResolvedType[] annotationtypes)
void	ResolvedMemberImpl.setAnnotationTypes(ResolvedType[] annotationTypes)
void	IntMap.setConcreteAspect(ResolvedType concreteAspect)
void	ShadowMunger.setDeclaringType(ResolvedType aType)	Invoked when the shadow munger of a resolved type are processed.
void	GeneratedReferenceTypeDelegate.setSuperclass(ResolvedType superclass)

Constructors in org.aspectj.weaver with parameters of type ResolvedType

Modifier	Constructor	Description
	AbstractAnnotationAJ(ResolvedType type)
	ArrayReferenceType(String sig, String erasureSig, World world, ResolvedType componentType)
	BindingScope(ResolvedType type, ISourceContext sourceContext, FormalBinding[] bindings)
	ConcreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
	CrosscuttingMembers(ResolvedType inAspect, boolean shouldConcretizeIfNeeded)
	JoinPointSignature(ResolvedMember backing, ResolvedType aType)
	NewParentTypeMunger(ResolvedType newParent, ResolvedType declaringType)
	ReferenceType(ResolvedType theGenericType, ResolvedType[] theParameters, World aWorld)	Constructor used when creating a parameterized type.
	ResolvedTypeArrayIterator(ResolvedType[] array, List<String> alreadySeen, boolean wantGenerics)
	StandardAnnotation(ResolvedType type, boolean isRuntimeVisible)
	TemporaryTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)

Uses of ResolvedType in org.aspectj.weaver.ast

Methods in org.aspectj.weaver.ast that return ResolvedType

Modifier and Type	Method	Description
ResolvedType	CallExpr.getType()
abstract ResolvedType	Expr.getType()
ResolvedType	FieldGet.getType()
ResolvedType	Var.getType()

Methods in org.aspectj.weaver.ast with parameters of type ResolvedType

Modifier and Type	Method	Description
Var	Var.getAccessorForValue(ResolvedType formalType, String formalName)	For an annotation this will return a variable that can access a specific field of the annotation (of the specified type) TODO what kind of behaviour happens for two annotation fields of the same type?
static CallExpr	Expr.makeCallExpr(Member member, Expr[] exprs, ResolvedType returnType)
static Test	Test.makeHasAnnotation(Var v, ResolvedType annTy)
static Test	Test.makeInstanceof(Var v, ResolvedType ty)

Constructors in org.aspectj.weaver.ast with parameters of type ResolvedType

Modifier	Constructor	Description
	CallExpr(Member m, Expr[] args, ResolvedType returnType)
	FieldGet(Member field, ResolvedType resolvedType)
	HasAnnotation(Var v, ResolvedType annType)
	Var(ResolvedType variableType)

Uses of ResolvedType in org.aspectj.weaver.bcel

Fields in org.aspectj.weaver.bcel declared as ResolvedType

Modifier and Type	Field	Description
ResolvedType	LazyMethodGen.definingType

Methods in org.aspectj.weaver.bcel that return ResolvedType

Modifier and Type	Method	Description
ResolvedType	BcelWeaver.addLibraryAspect(String aspectName)	Add the given aspect to the weaver.
static ResolvedType	BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(GenericSignature.ClassTypeSignature aClassTypeSignature, GenericSignature.FormalTypeParameter[] typeParams, World world)
static ResolvedType	BcelGenericSignatureToTypeXConverter.fieldTypeSignature2TypeX(GenericSignature.FieldTypeSignature aFieldTypeSignature, GenericSignature.FormalTypeParameter[] typeParams, World world)
protected ResolvedType[]	BcelShadow.getAnnotations(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType)
ResolvedType[]	BcelObjectType.getAnnotationTypes()
ResolvedType[]	LazyMethodGen.getAnnotationTypes()
ResolvedType[]	BcelObjectType.getDeclaredInterfaces()	Retrieves the declared interfaces - this allows for the generic signature on a type.
ResolvedType	BcelShadow.getEnclosingType()
ResolvedType	BcelObjectType.getOuterClass()
ResolvedType	BcelObjectType.getSuperclass()	Must take into account generic signature
ResolvedType	LazyClassGen.getSuperClass()
ResolvedType	LazyClassGen.getType()
ResolvedType	BcelWorld.resolve(Type t)
static ResolvedType	BcelGenericSignatureToTypeXConverter.typeSignature2TypeX(GenericSignature.TypeSignature aTypeSig, GenericSignature.FormalTypeParameter[] typeParams, World world)

Methods in org.aspectj.weaver.bcel with parameters of type ResolvedType

Modifier and Type	Method	Description
void	LazyClassGen.addInterface(ResolvedType newInterface, ISourceLocation sourceLocation)
static void	Utility.appendConversion(InstructionList il, InstructionFactory fact, ResolvedType fromType, ResolvedType toType)
void	AnnotationAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType)
void	AspectInstanceVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType)
void	BcelCflowAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType)
void	BcelVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType)
void	TypeAnnotationAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType)
boolean	BcelTypeMunger.attemptToModifySuperCalls(org.aspectj.weaver.bcel.BcelClassWeaver weaver, LazyClassGen newParentTarget, ResolvedType newParent)	The main part of implementing declare parents extends.
ConcreteTypeMunger	BcelWeavingSupport.concreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
ConcreteTypeMunger	BcelWeavingSupport.createAccessForInlineMunger(ResolvedType aspect)
Advice	BcelWeavingSupport.createAdviceMunger(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member signature, ResolvedType concreteAspect)
InstructionList	BcelCflowAccessVar.createLoadInstructions(ResolvedType toType, InstructionFactory fact)
InstructionList	TypeAnnotationAccessVar.createLoadInstructions(ResolvedType toType, InstructionFactory fact)
void	BcelWorld.demote(ResolvedType type)	Force demote a type.
Var	AnnotationAccessVar.getAccessorForValue(ResolvedType valueType, String formalName)	Return an object that can access a particular value of this annotation.
Field	LazyClassGen.getAnnotationCachingField(BcelShadow shadow, ResolvedType toType, boolean isWithin)	Create a field in the type containing the shadow where the annotation retrieved during binding can be stored - for later fast access.
protected ResolvedType[]	BcelShadow.getAnnotations(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType)
TypePattern	BcelWorld.getAspectScope(ResolvedType declaringType)
static BcelObjectType	BcelWorld.getBcelObjectType(ResolvedType concreteAspect)	Retrieve a bcel delegate for an aspect - this will return NULL if the delegate is an EclipseSourceType and not a BcelObjectType - this happens quite often when incrementally compiling.
protected ResolvedMember	BcelShadow.getRelevantMember(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType)
BcelVar	BcelShadow.getThisAspectInstanceVar(ResolvedType aspectType)
static boolean	LazyClassGen.hasSerialVersionUIDField(ResolvedType type)
boolean	BcelWorld.hasUnsatisfiedDependency(ResolvedType aspectType)
boolean	BcelWorld.isAspectIncluded(ResolvedType aspectType)
Var	BcelWeavingSupport.makeCflowAccessVar(ResolvedType formalType, Member cflowField, int arrayIndex)
ConcreteTypeMunger	BcelWeavingSupport.makePerClauseAspect(ResolvedType aspect, PerClause.Kind kind)	Register a munger for perclause @AJ aspect so that we add aspectOf(..) to them as needed
boolean	BcelAccessForInlineMunger.matches(ResolvedType onType)	Match only the aspect for which we act
boolean	BcelCflowCounterFieldAdder.matches(ResolvedType onType)
boolean	BcelCflowStackFieldAdder.matches(ResolvedType onType)
boolean	BcelPerClauseAspectAdder.matches(ResolvedType onType)
ConcreteTypeMunger	BcelTypeMunger.parameterizedFor(ResolvedType target)
static BcelVar[]	Utility.pushAndReturnArrayOfVars(ResolvedType[] proceedParamTypes, InstructionList il, InstructionFactory fact, LazyMethodGen enclosingMethod)
static List<AjAttribute>	AtAjAttributes.readAj5FieldAttributes(Field field, org.aspectj.weaver.bcel.BcelField bField, ResolvedType type, ISourceContext context, IMessageHandler msgHandler)	Extract field level annotations and turn them into AjAttributes.
static List<AjAttribute>	AtAjAttributes.readAj5MethodAttributes(Method method, org.aspectj.weaver.bcel.BcelMethod bMethod, ResolvedType type, ResolvedPointcutDefinition preResolvedPointcut, ISourceContext context, IMessageHandler msgHandler)	Extract method level annotations and turn them into AjAttributes.
void	LazyMethodGen.removeAnnotation(ResolvedType annotationType)
void	LazyClassGen.setSuperClass(ResolvedType newSuperclass)
protected void	BcelWorld.weaveInterTypeDeclarations(ResolvedType onType)
void	BcelWeaver.weaveNormalTypeMungers(ResolvedType onType)
void	BcelWeaver.weaveParentTypeMungers(ResolvedType onType)	Weaves new parents and annotations onto a type ("declare parents" and "declare @type") Algorithm: 1.

Constructors in org.aspectj.weaver.bcel with parameters of type ResolvedType

Modifier	Constructor	Description
	AnnotationAccessVar(BcelShadow shadow, Shadow.Kind kind, ResolvedType annotationType, UnresolvedType theTargetIsStoredHere, Member sig, boolean isWithin)
	AspectInstanceVar(ResolvedType type)
	BcelAccessForInlineMunger(ResolvedType aspectType)
	BcelAnnotation(AnnotationGen theBcelAnnotation, ResolvedType resolvedAnnotationType)
	BcelCflowAccessVar(ResolvedType type, Member stackField, int index)
	BcelFieldRef(ResolvedType type, String className, String fieldName)
	BcelPerClauseAspectAdder(ResolvedType aspect, PerClause.Kind kind)
	BcelTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
	BcelVar(ResolvedType type, int slot)
	TypeAnnotationAccessVar(ResolvedType type, BcelVar theAnnotatedTargetIsStoredHere)

Uses of ResolvedType in org.aspectj.weaver.internal.tools

Methods in org.aspectj.weaver.internal.tools with parameters of type ResolvedType

Modifier and Type	Method	Description
protected Pointcut	PointcutDesignatorHandlerBasedPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
ShadowMatch	StandardPointcutExpressionImpl.matchesStaticInitialization(ResolvedType aType)

Uses of ResolvedType in org.aspectj.weaver.ltw

Methods in org.aspectj.weaver.ltw that return ResolvedType

Modifier and Type	Method	Description
protected ResolvedType	LTWWorld.completeNonLocalType(ResolvedType ret)
ResolvedType	LTWWorld.resolve(Class aClass)

Methods in org.aspectj.weaver.ltw with parameters of type ResolvedType

Modifier and Type	Method	Description
protected void	LTWWorld.completeBinaryType(ResolvedType ret)
protected ResolvedType	LTWWorld.completeNonLocalType(ResolvedType ret)

Uses of ResolvedType in org.aspectj.weaver.model

Methods in org.aspectj.weaver.model with parameters of type ResolvedType

Modifier and Type	Method	Description
static void	AsmRelationshipProvider.addRelationship(AsmManager model, ResolvedType onType, ResolvedTypeMunger typeTransformer, ResolvedType originatingAspect)	Add a relationship for a type transformation (declare parents, intertype method declaration, declare annotation on type).

Uses of ResolvedType in org.aspectj.weaver.patterns

Fields in org.aspectj.weaver.patterns declared as ResolvedType

Modifier and Type	Field	Description
protected ResolvedType	PerClause.inAspect
protected ResolvedType	ExactTypePattern.resolvedType

Methods in org.aspectj.weaver.patterns that return ResolvedType

Modifier and Type	Method	Description
ResolvedType	DeclareAnnotation.getAnnotationType()
ResolvedType	ExposedState.getConcreteAspect()
ResolvedType	Declare.getDeclaringType()
ResolvedType	IScope.getEnclosingType()
ResolvedType	ScopeWithTypeVariables.getEnclosingType()
ResolvedType	SimpleScope.getEnclosingType()
ResolvedType	ExactAnnotationFieldTypePattern.getResolvedAnnotationType()
ResolvedType	ExactAnnotationTypePattern.getResolvedAnnotationType()
ResolvedType	ExactTypePattern.getResolvedExactType(World world)
ResolvedType	FastMatchInfo.getType()

Methods in org.aspectj.weaver.patterns that return types with arguments of type ResolvedType

Modifier and Type	Method	Description
List<ResolvedType>	DeclareParents.findMatchingNewParents(ResolvedType onType, boolean reportErrors)

Methods in org.aspectj.weaver.patterns with parameters of type ResolvedType

Modifier and Type	Method	Description
FuzzyBoolean	TypePatternQuestions.askQuestion(TypePattern pattern, ResolvedType type, TypePattern.MatchKind kind)
int	DeclarePrecedence.compare(ResolvedType aspect1, ResolvedType aspect2)
PerClause	PerCflow.concretize(ResolvedType inAspect)
abstract PerClause	PerClause.concretize(ResolvedType inAspect)
PerClause	PerFromSuper.concretize(ResolvedType inAspect)
PerClause	PerObject.concretize(ResolvedType inAspect)
PerClause	PerSingleton.concretize(ResolvedType inAspect)
PerClause	PerTypeWithin.concretize(ResolvedType inAspect)
final Pointcut	Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity)	Returns a new pointcut Only used by test cases
final Pointcut	Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity, ShadowMunger advice)
final Pointcut	Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	AndPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected Pointcut	AnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected Pointcut	ArgsAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	ArgsPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	CflowPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	ConcreteCflowPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	HandlerPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	IfPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	IfPointcut.IfFalsePointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	IfPointcut.IfTruePointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	KindedPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	NotPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	OrPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
final Pointcut	PerClause.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected abstract Pointcut	Pointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)	Resolves and removes ReferencePointcuts, replacing with basic ones
Pointcut	ReferencePointcut.concretize1(ResolvedType searchStart, ResolvedType declaringType, IntMap bindings)
protected Pointcut	ThisOrTargetAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	ThisOrTargetPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected Pointcut	WithinAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected Pointcut	WithinCodeAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	WithincodePointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Pointcut	WithinPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
void	DeclareAnnotation.copyAnnotationTo(ResolvedType onType)
boolean	AndSignaturePattern.couldEverMatch(ResolvedType type)
boolean	DeclareAnnotation.couldEverMatch(ResolvedType type)	Return true if this declare annotation could ever match something in the specified type - only really able to make intelligent decision if a type was specified in the sig/type pattern signature.
boolean	ISignaturePattern.couldEverMatch(ResolvedType type)
boolean	NotSignaturePattern.couldEverMatch(ResolvedType type)
boolean	OrSignaturePattern.couldEverMatch(ResolvedType type)
boolean	SignaturePattern.couldEverMatch(ResolvedType type)
boolean	SignaturePattern.declaringTypeMatchAllowingForCovariance(Member member, UnresolvedType shadowDeclaringType, World world, TypePattern returnTypePattern, ResolvedType sigReturn)
List<ResolvedType>	DeclareParents.findMatchingNewParents(ResolvedType onType, boolean reportErrors)
protected boolean	HasMemberTypePattern.hasMethod(ResolvedType type)
protected boolean	HasMemberTypePatternForPerThisMatching.hasMethod(ResolvedType type)
PerClause	PerFromSuper.lookupConcretePerClause(ResolvedType lookupType)
boolean	DeclareParents.match(ResolvedType typeX)
FuzzyBoolean	AndAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
FuzzyBoolean	AnnotationPatternList.matches(ResolvedType[] someArgs)
abstract FuzzyBoolean	AnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
FuzzyBoolean	AnyAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
FuzzyBoolean	BindingAnnotationFieldTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
boolean	DeclareAnnotation.matches(ResolvedType type)	For declare atType.
FuzzyBoolean	ExactAnnotationFieldTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
FuzzyBoolean	ExactAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
FuzzyBoolean	NotAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
FuzzyBoolean	OrAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
final FuzzyBoolean	TypePattern.matches(ResolvedType type, TypePattern.MatchKind kind)
FuzzyBoolean	TypePatternList.matches(ResolvableTypeList types, TypePattern.MatchKind kind, ResolvedType[][] parameterAnnotations)
FuzzyBoolean	TypePatternList.matches(ResolvedType[] types, TypePattern.MatchKind kind)
FuzzyBoolean	TypePatternList.matches(ResolvedType[] types, TypePattern.MatchKind kind, ResolvedType[][] parameterAnnotations)	When called with TypePattern.STATIC this will always return either FuzzyBoolean.YES or FuzzyBoolean.NO.
FuzzyBoolean	WildAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
protected boolean	AndTypePattern.matchesExactly(ResolvedType type)
protected boolean	AndTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	AnyTypePattern.matchesExactly(ResolvedType type)
protected boolean	AnyTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	AnyWithAnnotationTypePattern.matchesExactly(ResolvedType type)
protected boolean	AnyWithAnnotationTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	EllipsisTypePattern.matchesExactly(ResolvedType type)
protected boolean	EllipsisTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	ExactTypePattern.matchesExactly(ResolvedType matchType)
protected boolean	ExactTypePattern.matchesExactly(ResolvedType matchType, ResolvedType annotatedType)
protected boolean	HasMemberTypePattern.matchesExactly(ResolvedType type)
protected boolean	HasMemberTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	NotTypePattern.matchesExactly(ResolvedType type)
protected boolean	NotTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	NoTypePattern.matchesExactly(ResolvedType type)
protected boolean	NoTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	OrTypePattern.matchesExactly(ResolvedType type)
protected boolean	OrTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	TypeCategoryTypePattern.matchesExactly(ResolvedType type)
protected boolean	TypeCategoryTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected abstract boolean	TypePattern.matchesExactly(ResolvedType type)
protected abstract boolean	TypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean	WildTypePattern.matchesExactly(ResolvedType type)
protected boolean	WildTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
FuzzyBoolean	AndTypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	AnyTypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	AnyWithAnnotationTypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	EllipsisTypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	ExactTypePattern.matchesInstanceof(ResolvedType matchType)
FuzzyBoolean	HasMemberTypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	NotTypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	NoTypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	OrTypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	TypeCategoryTypePattern.matchesInstanceof(ResolvedType type)
abstract FuzzyBoolean	TypePattern.matchesInstanceof(ResolvedType type)
FuzzyBoolean	WildTypePattern.matchesInstanceof(ResolvedType type)
boolean	AndTypePattern.matchesStatically(ResolvedType type)
boolean	NotTypePattern.matchesStatically(ResolvedType type)
boolean	OrTypePattern.matchesStatically(ResolvedType type)
boolean	TypePattern.matchesStatically(ResolvedType type)
protected boolean	AnyTypePattern.matchesSubtypes(ResolvedType type)
protected boolean	AnyWithAnnotationTypePattern.matchesSubtypes(ResolvedType type)
protected boolean	ExactTypePattern.matchesSubtypes(ResolvedType type)
protected boolean	NoTypePattern.matchesSubtypes(ResolvedType type)
protected boolean	TypePattern.matchesSubtypes(ResolvedType type)
protected boolean	TypePattern.matchesSubtypes(ResolvedType superType, ResolvedType annotatedType)
void	ArgsPointcut.postRead(ResolvedType enclosingType)
void	IfPointcut.IfFalsePointcut.postRead(ResolvedType enclosingType)
void	IfPointcut.IfTruePointcut.postRead(ResolvedType enclosingType)
void	KindedPointcut.postRead(ResolvedType enclosingType)
void	Pointcut.postRead(ResolvedType enclosingType)
void	ReferencePointcut.postRead(ResolvedType enclosingType)
void	SignaturePattern.postRead(ResolvedType enclosingType)
void	ThisOrTargetPointcut.postRead(ResolvedType enclosingType)
void	TypePattern.postRead(ResolvedType enclosingType)
void	TypePatternList.postRead(ResolvedType enclosingType)
void	WithincodePointcut.postRead(ResolvedType enclosingType)
void	WithinPointcut.postRead(ResolvedType enclosingType)
protected void	WildAnnotationTypePattern.resolveAnnotationValues(ResolvedType annotationType, IScope scope)	Resolve any annotation values specified, checking they are all well formed (valid names, valid values)
void	DeclareAnnotation.setAspect(ResolvedType typeX)
void	ExposedState.setConcreteAspect(ResolvedType concreteAspect)
void	Declare.setDeclaringType(ResolvedType aType)
protected void	ExactAnnotationTypePattern.verifyIsAnnotationType(ResolvedType type, IScope scope)

Constructors in org.aspectj.weaver.patterns with parameters of type ResolvedType

Modifier	Constructor	Description
	ConcreteCflowPointcut(ResolvedType aspect, Member cflowField, List<ConcreteCflowPointcut.Slot> slots, boolean usesCounter)
	FastMatchInfo(ResolvedType type, Shadow.Kind kind, World world)
	PerThisOrTargetPointcutVisitor(boolean isTarget, ResolvedType fromAspectType)
	Question(TypePattern pattern, ResolvedType type, TypePattern.MatchKind kind)
	Slot(int formalIndex, ResolvedType formalType, int arrayIndex)

Uses of ResolvedType in org.aspectj.weaver.reflect

Fields in org.aspectj.weaver.reflect declared as ResolvedType

Modifier and Type	Field	Description
static final ResolvedType[][]	Java15AnnotationFinder.NO_PARAMETER_ANNOTATIONS

Methods in org.aspectj.weaver.reflect that return ResolvedType

Modifier and Type	Method	Description
ResolvedType	JavaLangTypeToResolvedTypeConverter.fromType(Type type)
ResolvedType[]	JavaLangTypeToResolvedTypeConverter.fromTypes(Type[] types)
ResolvedType[]	AnnotationFinder.getAnnotations(Member onMember, boolean runtimeAnnotationsOnly)
ResolvedType[]	Java15AnnotationFinder.getAnnotations(Class forClass, World inWorld)
ResolvedType[]	Java15AnnotationFinder.getAnnotations(Member onMember, boolean areRuntimeAnnotationsSufficient)
ResolvedType[]	Java15ReflectionBasedReferenceTypeDelegate.getAnnotationTypes()
ResolvedType[]	ReflectionBasedReferenceTypeDelegate.getAnnotationTypes()
ResolvedType[]	ReflectionBasedResolvedMemberImpl.getAnnotationTypes()
ResolvedType[]	Java15ReflectionBasedReferenceTypeDelegate.getDeclaredInterfaces()
ResolvedType[]	ReflectionBasedReferenceTypeDelegate.getDeclaredInterfaces()
ResolvedType	Java15ReflectionBasedReferenceTypeDelegate.getGenericResolvedType()	Returns the generic type, regardless of the resolvedType we 'know about'
ResolvedType	Java15ReflectionBasedReferenceTypeDelegate.getOuterClass()
ResolvedType	ReflectionBasedReferenceTypeDelegate.getOuterClass()
ResolvedType[][]	AnnotationFinder.getParameterAnnotationTypes(Member onMember)
ResolvedType[][]	Java15AnnotationFinder.getParameterAnnotationTypes(Member onMember)
ResolvedType[][]	ReflectionBasedResolvedMemberImpl.getParameterAnnotationTypes()
ResolvedType	Java15ReflectionBasedReferenceTypeDelegate.getSuperclass()
ResolvedType	ReflectionBasedReferenceTypeDelegate.getSuperclass()
ResolvedType	IReflectionWorld.resolve(Class aClass)
ResolvedType	ReflectionWorld.resolve(Class aClass)
static ResolvedType	ReflectionWorld.resolve(World world, Class<?> aClass)
static ResolvedType	ReflectionBasedReferenceTypeDelegateFactory.resolveTypeInWorld(Class aClass, World aWorld)
ResolvedType	ReflectionWorld.resolveUsingClass(Class<?> clazz)	Resolve a type using the specified class.

Methods in org.aspectj.weaver.reflect with parameters of type ResolvedType

Modifier and Type	Method	Description
static ReflectionVar	ReflectionVar.createArgsAnnotationVar(ResolvedType type, int index, AnnotationFinder finder)
static ReflectionVar	ReflectionVar.createArgsVar(ResolvedType type, int index, AnnotationFinder finder)
static ReflectionVar	ReflectionVar.createAtAnnotationVar(ResolvedType annType, AnnotationFinder finder)
static ReflectionVar	ReflectionVar.createTargetAnnotationVar(ResolvedType type, AnnotationFinder finder)
static ReflectionVar	ReflectionVar.createTargetVar(ResolvedType type, AnnotationFinder finder)
static ReflectionVar	ReflectionVar.createThisAnnotationVar(ResolvedType type, AnnotationFinder finder)
static ReflectionVar	ReflectionVar.createThisVar(ResolvedType type, AnnotationFinder finder)
static ReflectionVar	ReflectionVar.createWithinAnnotationVar(ResolvedType annType, AnnotationFinder finder)
static ReflectionVar	ReflectionVar.createWithinCodeAnnotationVar(ResolvedType annType, AnnotationFinder finder)
Object	AnnotationFinder.getAnnotation(ResolvedType annotationType, Object onObject)
Object	Java15AnnotationFinder.getAnnotation(ResolvedType annotationType, Object onObject)
Object	AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType, Class<?> aClass)
Object	Java15AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType, Class aClass)
Object	AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType, Member aMember)
Object	Java15AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType, Member aMember)
Var	ReflectionShadow.getThisAspectInstanceVar(ResolvedType aspectType)
Var	StandardShadow.getThisAspectInstanceVar(ResolvedType aspectType)
static Shadow	StandardShadow.makeStaticInitializationShadow(World inWorld, ResolvedType forType, MatchingContext withContext)
void	StandardShadowMatchImpl.setWithinType(ResolvedType aClass)

Constructors in org.aspectj.weaver.reflect with parameters of type ResolvedType

Modifier	Constructor	Description
	ReflectionFastMatchInfo(ResolvedType type, Shadow.Kind kind, MatchingContext context, World world)
	ReflectionShadow(World world, Shadow.Kind kind, Member signature, Shadow enclosingShadow, ResolvedType enclosingType, ResolvedMember enclosingMember, MatchingContext withContext)
	StandardShadow(World world, Shadow.Kind kind, Member signature, Shadow enclosingShadow, ResolvedType enclosingType, ResolvedMember enclosingMember, MatchingContext withContext)

Uses of ResolvedType in org.aspectj.weaver.tools

Methods in org.aspectj.weaver.tools with parameters of type ResolvedType

Modifier and Type	Method	Description
ShadowMatch	StandardPointcutExpression.matchesStaticInitialization(ResolvedType aType)	Determine whether or not this pointcut matches the static initialization of the given class.