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
class	BoundedReferenceType
class	MissingResolvedTypeWithKnownSignature
class	ReferenceType
class	TypeVariableReferenceType

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 ResolvedType[]	ResolvedType.EMPTY_ARRAY
static ResolvedType[]	ResolvedType.EMPTY_RESOLVED_TYPE_ARRAY
static ResolvedType[][]	Member.NO_PARAMETER_ANNOTATION_TYPES
static ResolvedType[]	ResolvedType.NONE
protected ResolvedType[][]	ResolvedMemberImpl.parameterAnnotationTypes
ResolvedType[]	ResolvedType.temporaryAnnotationTypes
protected ResolvedType	AbstractAnnotationAJ.type

Methods in org.aspectj.weaver that return ResolvedType

Modifier and Type	Method	Description
ResolvedType	ResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)
ResolvedType	CrosscuttingMembersSet.findAspectDeclaringParents(DeclareParents p)
ResolvedType	World.TypeMap.get(String key)
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)
ResolvedType[]	ArrayReferenceType.getDeclaredInterfaces()
ResolvedType[]	BoundedReferenceType.getDeclaredInterfaces()
ResolvedType[]	GeneratedReferenceTypeDelegate.getDeclaredInterfaces()
ResolvedType[]	MissingResolvedTypeWithKnownSignature.getDeclaredInterfaces()
ResolvedType[]	ReferenceType.getDeclaredInterfaces()
ResolvedType[]	ReferenceTypeDelegate.getDeclaredInterfaces()
abstract ResolvedType[]	ResolvedType.getDeclaredInterfaces()
ResolvedType	NewParentTypeMunger.getDeclaringType()
ResolvedType	ResolvedType.getDeclaringType()
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()
ResolvedType	ArrayReferenceType.getSuperclass()
ResolvedType	GeneratedReferenceTypeDelegate.getSuperclass()
ResolvedType	MissingResolvedTypeWithKnownSignature.getSuperclass()
ResolvedType	ReferenceType.getSuperclass()
ResolvedType	ReferenceTypeDelegate.getSuperclass()
abstract ResolvedType	ResolvedType.getSuperclass()
ResolvedType	ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
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)
ResolvedType	World.TypeMap.remove(String key)
ResolvedType	TypeVariableReferenceType.resolve(World world)
ResolvedType	UnresolvedType.resolve(World world)
ResolvedType	UnresolvedTypeVariableReferenceType.resolve(World world)
ResolvedType	World.resolve(String name)
ResolvedType	World.resolve(String name, boolean allowMissing)
ResolvedType	World.resolve(ResolvedType ty)
ResolvedType	World.resolve(UnresolvedType ty)
ResolvedType[]	World.resolve(UnresolvedType[] types)
ResolvedType	World.resolve(UnresolvedType ty, boolean allowMissing)
ResolvedType	World.resolve(UnresolvedType ty, ISourceLocation isl)
ResolvedType	World.resolveGenericTypeFor(UnresolvedType anUnresolvedType, boolean allowMissing)

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)
Iterator<ResolvedType>	ResolvedType.getDirectSupertypes()
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()
Iterator<ResolvedType>	ResolvedType.getHierarchy(boolean wantGenerics, boolean wantDeclaredParents)
List<ResolvedType>	ResolvedType.getHierarchyWithoutIterator(boolean includeITDs, boolean allowMissing, boolean genericsAware)
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)
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)
int	World.compareByPrecedenceAndHierarchy(ResolvedType aspect1, ResolvedType aspect2)
protected void	World.completeBinaryType(ResolvedType ret)
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)
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)
Advice	World.createAdviceMunger(AdviceKind kind, Pointcut p, Member signature, int extraParameterFlags, IHasSourceLocation loc, ResolvedType declaringAspect)
Collection<ShadowMunger>	CustomMungerFactory.createCustomShadowMungers(ResolvedType aspectType)
Collection<ConcreteTypeMunger>	CustomMungerFactory.createCustomTypeMungers(ResolvedType aspectType)
static ReferenceType	TypeFactory.createParameterizedType(ResolvedType aBaseType, UnresolvedType[] someTypeParameters, World inAWorld)
void	World.TypeMap.demote(ResolvedType type)
ResolvedType	ResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)
ReferenceType	ReferenceType.findDerivativeType(ResolvedType[] typeParameters)
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)
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)
static ResolvedMember	AjcMemberMaker.interFieldInterfaceSetter(ResolvedMember field, ResolvedType onType, UnresolvedType aspectType)
boolean	WeaverStateInfo.isAspectAlreadyApplied(ResolvedType someAspect)
boolean	World.isAspectIncluded(ResolvedType aspectType)
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)
abstract boolean	ResolvedType.isAssignableFrom(ResolvedType other, boolean allowMissing)
boolean	ArrayReferenceType.isCoerceableFrom(ResolvedType o)
boolean	MissingResolvedTypeWithKnownSignature.isCoerceableFrom(ResolvedType other)
boolean	ReferenceType.isCoerceableFrom(ResolvedType o)
abstract boolean	ResolvedType.isCoerceableFrom(ResolvedType other)
boolean	ResolvedType.isConvertableFrom(ResolvedType other)
protected boolean	World.isExpendable(ResolvedType type)
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)
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)
boolean	MethodDelegateTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
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)
ResolvedTypeMunger	NewConstructorTypeMunger.parameterizedFor(ResolvedType target)
ResolvedTypeMunger	NewFieldTypeMunger.parameterizedFor(ResolvedType target)
ResolvedTypeMunger	NewMethodTypeMunger.parameterizedFor(ResolvedType target)
ResolvedTypeMunger	ResolvedTypeMunger.parameterizedFor(ResolvedType target)
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)
ResolvedMemberImpl	ResolvedPointcutDefinition.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
ShadowMunger	Checker.parameterizeWith(ResolvedType declaringType, Map<String,UnresolvedType> typeVariableMap)
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)
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)
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)
void	GeneratedReferenceTypeDelegate.setSuperclass(ResolvedType superclass)

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

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)
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)
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

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)
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()
ResolvedType	BcelShadow.getEnclosingType()
ResolvedType	BcelObjectType.getOuterClass()
ResolvedType	BcelObjectType.getSuperclass()
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)
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)
Var	AnnotationAccessVar.getAccessorForValue(ResolvedType valueType, String formalName)
Field	LazyClassGen.getAnnotationCachingField(BcelShadow shadow, ResolvedType toType, boolean isWithin)
protected ResolvedType[]	BcelShadow.getAnnotations(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType)
TypePattern	BcelWorld.getAspectScope(ResolvedType declaringType)
static BcelObjectType	BcelWorld.getBcelObjectType(ResolvedType concreteAspect)
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)
boolean	BcelAccessForInlineMunger.matches(ResolvedType onType)
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)
static List<AjAttribute>	AtAjAttributes.readAj5MethodAttributes(Method method, org.aspectj.weaver.bcel.BcelMethod bMethod, ResolvedType type, ResolvedPointcutDefinition preResolvedPointcut, ISourceContext context, IMessageHandler msgHandler)
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)

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

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)

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)
Pointcut	Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity)
Pointcut	Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity, ShadowMunger advice)
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)
Pointcut	PerClause.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected abstract Pointcut	Pointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
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)
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)
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)
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)
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)
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

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 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()
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)

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

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)