Uses of Class
org.aspectj.weaver.ResolvedType

Packages that use ResolvedType
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
 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 representing a type variable.
 

Fields in org.aspectj.weaver declared as ResolvedType
static ResolvedType[] ResolvedType.EMPTY_ARRAY
           
static ResolvedType[] ResolvedType.EMPTY_RESOLVED_TYPE_ARRAY
           
static ResolvedType[][] Member.NO_PARAMETER_ANNOTATION_TYPES
           
static ResolvedType[] ResolvedType.NONE
           
 ResolvedType[] ResolvedType.temporaryAnnotationTypes
           
 

Methods in org.aspectj.weaver that return ResolvedType
 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(java.lang.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[] ResolvedType.getAnnotationTypes()
           
 ResolvedType[] ResolvedMember.getAnnotationTypes()
           
 ResolvedType[] ResolvedMemberImpl.getAnnotationTypes()
           
 ResolvedType[] GeneratedReferenceTypeDelegate.getAnnotationTypes()
           
 ResolvedType[] ReferenceType.getAnnotationTypes()
           
 ResolvedType[] ReferenceTypeDelegate.getAnnotationTypes()
           
 ResolvedType[] JoinPointSignature.getAnnotationTypes()
           
 ResolvedType[] Shadow.getArgumentTypesForArrayConstructionShadow()
           
 ResolvedType ConcreteTypeMunger.getAspectType()
           
 ResolvedType Advice.getConcreteAspect()
           
abstract  ResolvedType ShadowMunger.getConcreteAspect()
           
 ResolvedType Checker.getConcreteAspect()
           
 ResolvedType IntMap.getConcreteAspect()
           
 ResolvedType World.getCoreType(UnresolvedType tx)
          Special resolution for "core" types like OBJECT.
 ResolvedType[] ArrayReferenceType.getDeclaredInterfaces()
           
abstract  ResolvedType[] ResolvedType.getDeclaredInterfaces()
           
 ResolvedType[] MissingResolvedTypeWithKnownSignature.getDeclaredInterfaces()
           
 ResolvedType[] GeneratedReferenceTypeDelegate.getDeclaredInterfaces()
           
 ResolvedType[] ReferenceType.getDeclaredInterfaces()
          Find out from the generic signature the true signature of any interfaces I implement.
 ResolvedType[] ReferenceTypeDelegate.getDeclaredInterfaces()
           
 ResolvedType[] BoundedReferenceType.getDeclaredInterfaces()
           
 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 NewParentTypeMunger.getDeclaringType()
           
 ResolvedType BindingScope.getEnclosingType()
           
 ResolvedType ResolvedType.getGenericType()
          Overridden by ReferenceType to return a sensible answer for parameterized and raw types.
 ResolvedType ReferenceType.getGenericType()
           
 ResolvedType NewParentTypeMunger.getNewParent()
           
 ResolvedType GeneratedReferenceTypeDelegate.getOuterClass()
           
 ResolvedType ReferenceType.getOuterClass()
           
 ResolvedType ReferenceTypeDelegate.getOuterClass()
           
 ResolvedType[][] ResolvedMember.getParameterAnnotationTypes()
           
 ResolvedType[][] ResolvedMemberImpl.getParameterAnnotationTypes()
           
 ResolvedType[][] JoinPointSignature.getParameterAnnotationTypes()
           
 ResolvedType ResolvedType.getRawType()
           
 ResolvedType ResolvableTypeList.getResolved(int nameIndex)
           
 ResolvedType ArrayReferenceType.getResolvedComponentType()
           
 ResolvedType ResolvedType.getResolvedComponentType()
           
 ResolvedType[] ResolvedType.getResolvedTypeParameters()
           
 ResolvedType ArrayReferenceType.getSuperclass()
           
abstract  ResolvedType ResolvedType.getSuperclass()
           
 ResolvedType MissingResolvedTypeWithKnownSignature.getSuperclass()
           
 ResolvedType GeneratedReferenceTypeDelegate.getSuperclass()
           
 ResolvedType ReferenceType.getSuperclass()
           
 ResolvedType ReferenceTypeDelegate.getSuperclass()
           
 ResolvedType ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
           
 ResolvedType AnnotationAJ.getType()
           
 ResolvedType AbstractAnnotationAJ.getType()
          
static ResolvedType ResolvedType.makeArray(ResolvedType type, int dim)
           
 ResolvedType Iterators.ResolvedTypeArrayIterator.next()
           
 ResolvedType ResolvedType.parameterizedWith(UnresolvedType[] typeParameters)
           
 ResolvedType World.TypeMap.put(java.lang.String key, ResolvedType type)
          Add a new type into the map, the key is the type signature.
 ResolvedType World.TypeMap.remove(java.lang.String key)
          Remove a type from the map
 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(java.lang.String name)
          Convenience method for finding a type by name and resolving it in one step.
 ResolvedType World.resolve(java.lang.String name, boolean allowMissing)
           
 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 UnresolvedType.resolve(World world)
          Returns a resolved version of this type according to a particular world.
 ResolvedType UnresolvedTypeVariableReferenceType.resolve(World world)
           
 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
static java.util.Iterator<ResolvedType> Iterators.array(ResolvedType[] o, boolean genericsAware)
           
 java.util.Collection<ResolvedType> Member.getDeclaringTypes(World world)
           
 java.util.Collection<ResolvedType> MemberImpl.getDeclaringTypes(World world)
           
 java.util.Collection<ResolvedType> JoinPointSignature.getDeclaringTypes(World world)
           
 java.util.Iterator<ResolvedType> ResolvedType.getDirectSupertypes()
          Returns an iterator through ResolvedType objects representing all the direct supertypes of this type.
 java.util.Map<ResolvedType,java.util.Set<ResolvedType>> World.getExclusionMap()
           
 java.util.Map<ResolvedType,java.util.Set<ResolvedType>> World.getExclusionMap()
           
 java.util.Map<java.lang.String,java.lang.ref.Reference<ResolvedType>> World.getExpendable()
           
 java.util.Map<java.lang.String,java.lang.ref.Reference<ResolvedType>> World.TypeMap.getExpendableMap()
           
 java.util.Map<java.lang.String,ResolvedType> World.getFixed()
           
 java.util.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).
 java.util.Iterator<ResolvedType> ResolvedType.getHierarchy(boolean wantGenerics, boolean wantDeclaredParents)
           
 java.util.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.
 java.util.Map<java.lang.String,ResolvedType> World.TypeMap.getMainMap()
           
abstract  java.util.Collection<ResolvedType> ShadowMunger.getThrownExceptions()
           
 java.util.Collection<ResolvedType> Checker.getThrownExceptions()
           
 

Methods in org.aspectj.weaver with parameters of type ResolvedType
 void CrosscuttingMembersSet.addAdviceLikeDeclares(ResolvedType aspectType)
           
 void CrosscuttingMembersSet.addFixedCrosscuttingMembers(ResolvedType aspectType)
           
 boolean CrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType)
           
 boolean CrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType, boolean inWeavingPhase)
           
 void ResolvedType.addParent(ResolvedType newParent)
           
 void ReferenceType.addParent(ResolvedType newParent)
           
 boolean BoundedReferenceType.alwaysMatches(ResolvedType aCandidateType)
           
static java.util.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.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
 ConcreteTypeMunger IWeavingSupport.concreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
           
 ShadowMunger Advice.concretize(ResolvedType fromType, World world, PerClause clause)
           
abstract  ShadowMunger ShadowMunger.concretize(ResolvedType fromType, World world, PerClause clause)
           
 ShadowMunger Checker.concretize(ResolvedType theAspect, World world, PerClause clause)
          Concretize this Checker by concretizing the pointcut
 ConcreteTypeMunger IWeavingSupport.createAccessForInlineMunger(ResolvedType inAspect)
           
 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
 Advice IWeavingSupport.createAdviceMunger(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member signature, ResolvedType concreteAspect)
           
 java.util.Collection<ShadowMunger> CustomMungerFactory.createCustomShadowMungers(ResolvedType aspectType)
           
 java.util.Collection<ConcreteTypeMunger> CustomMungerFactory.createCustomTypeMungers(ResolvedType aspectType)
           
static ReferenceType TypeFactory.createParameterizedType(ResolvedType aBaseType, UnresolvedType[] someTypeParameters, World inAWorld)
          Create a parameterized version of a generic type.
 ResolvedType ResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)
          Look up the actual occurence of a particular type in the hierarchy for 'this' type.
 TypePattern World.getAspectScope(ResolvedType declaringType)
           
 ResolvedMember MethodDelegateTypeMunger.getDelegate(ResolvedType targetType)
           
 ResolvedMember NewMethodTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
           
 ResolvedMember NewFieldTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
           
 ResolvedMember ResolvedTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
           
 ResolvedMember PrivilegedAccessMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
           
 ResolvedMember NewConstructorTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
           
 java.lang.Integer World.getPrecedenceIfAny(ResolvedType aspect1, ResolvedType aspect2)
           
 ResolvedType ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
           
 java.util.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)
           
 boolean ArrayReferenceType.isAssignableFrom(ResolvedType o)
           
abstract  boolean ResolvedType.isAssignableFrom(ResolvedType other)
          Determines if the variables of this type could be assigned values of another type without casting.
 boolean MissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other)
           
 boolean ReferenceType.isAssignableFrom(ResolvedType other)
           
 boolean ArrayReferenceType.isAssignableFrom(ResolvedType o, boolean allowMissing)
           
abstract  boolean ResolvedType.isAssignableFrom(ResolvedType other, boolean allowMissing)
           
 boolean MissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other, boolean allowMissing)
           
 boolean ReferenceType.isAssignableFrom(ResolvedType other, boolean allowMissing)
           
 boolean ArrayReferenceType.isCoerceableFrom(ResolvedType o)
           
abstract  boolean ResolvedType.isCoerceableFrom(ResolvedType other)
          Determines if values of another type could possibly be cast to this type.
 boolean MissingResolvedTypeWithKnownSignature.isCoerceableFrom(ResolvedType other)
           
 boolean ReferenceType.isCoerceableFrom(ResolvedType o)
           
 boolean ResolvedType.isConvertableFrom(ResolvedType other)
          Determines if variables of this type could be assigned values of another with lots of help.
 boolean ResolvedType.isTopmostImplementor(ResolvedType interfaceType)
           
static boolean ResolvedType.isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType)
           
 boolean ResolvedMember.isVisible(ResolvedType fromType)
           
 boolean ResolvedMemberImpl.isVisible(ResolvedType fromType)
           
 boolean JoinPointSignature.isVisible(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, java.util.List<ShadowMunger> innerCflowEntries, ResolvedType inAspect)
           
static Advice Advice.makePerCflowEntry(World world, Pointcut entry, boolean isBelow, Member stackField, ResolvedType inAspect, java.util.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 ResolvedTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
           
 boolean PerTypeWithinTargetTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
           
 boolean MethodDelegateTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
          Match based on given type pattern, only classes can be matched
 boolean MethodDelegateTypeMunger.FieldHostTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
          Match based on given type pattern, only classes can be matched
 boolean PerObjectInterfaceTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
           
 boolean ResolvedType.needsNoConversionFrom(ResolvedType o)
           
 ResolvedTypeMunger NewMethodTypeMunger.parameterizedFor(ResolvedType target)
          see ResolvedTypeMunger.parameterizedFor(ResolvedType)
 ResolvedTypeMunger NewFieldTypeMunger.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
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.
 ConcreteTypeMunger TemporaryTypeMunger.parameterizedFor(ResolvedType targetType)
           
 ResolvedTypeMunger NewConstructorTypeMunger.parameterizedFor(ResolvedType target)
          see ResolvedTypeMunger.parameterizedFor(ResolvedType)
 ResolvedMemberImpl ResolvedMember.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
           
 ResolvedMemberImpl ResolvedMemberImpl.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
           
 ResolvedMemberImpl JoinPointSignature.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
           
 ResolvedMemberImpl ResolvedPointcutDefinition.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
          Called when asking a parameterized super-aspect for its pointcuts.
 ResolvedMemberImpl ResolvedMember.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, java.util.List<java.lang.String> aliases)
           
 ResolvedMemberImpl ResolvedMemberImpl.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, java.util.List<java.lang.String> aliases)
          Return a resolvedmember in which all the type variables in the signature have been replaced with the given bindings.
 ResolvedMemberImpl JoinPointSignature.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, java.util.List<java.lang.String> aliases)
           
abstract  ShadowMunger ShadowMunger.parameterizeWith(ResolvedType declaringType, java.util.Map<java.lang.String,UnresolvedType> typeVariableMap)
           
 ShadowMunger Checker.parameterizeWith(ResolvedType declaringType, java.util.Map<java.lang.String,UnresolvedType> typeVariableMap)
          Parameterize the Checker by parameterizing the pointcut
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(java.lang.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 ResolvedMember.setAnnotationTypes(ResolvedType[] annotationtypes)
           
 void ResolvedMemberImpl.setAnnotationTypes(ResolvedType[] annotationTypes)
           
 void JoinPointSignature.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
AbstractAnnotationAJ(ResolvedType type)
           
ArrayReferenceType(java.lang.String sig, java.lang.String erasureSig, World world, ResolvedType componentType)
           
BindingScope(ResolvedType type, ISourceContext sourceContext, FormalBinding[] bindings)
           
ConcreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
           
CrosscuttingMembers(ResolvedType inAspect, boolean shouldConcretizeIfNeeded)
           
Iterators.ResolvedTypeArrayIterator(ResolvedType[] array, java.util.List<java.lang.String> alreadySeen, boolean wantGenerics)
           
JoinPointSignature(ResolvedMember backing, ResolvedType aType)
           
NewParentTypeMunger(ResolvedType newParent, ResolvedType declaringType)
           
ReferenceType(ResolvedType theGenericType, ResolvedType[] theParameters, World aWorld)
          Constructor used when creating a parameterized type.
ReferenceType(ResolvedType theGenericType, ResolvedType[] theParameters, World aWorld)
          Constructor used when creating a parameterized type.
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
 ResolvedType Var.getType()
           
 ResolvedType FieldGet.getType()
           
abstract  ResolvedType Expr.getType()
           
 ResolvedType CallExpr.getType()
           
 

Methods in org.aspectj.weaver.ast with parameters of type ResolvedType
 Var Var.getAccessorForValue(ResolvedType formalType)
          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
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
 ResolvedType LazyMethodGen.definingType
           
 

Methods in org.aspectj.weaver.bcel that return ResolvedType
 ResolvedType BcelWeaver.addLibraryAspect(java.lang.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)
           
 ResolvedType[] BcelObjectType.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
 void LazyClassGen.addInterface(ResolvedType newInterface, ISourceLocation sourceLocation)
           
static void Utility.appendConversion(InstructionList il, InstructionFactory fact, ResolvedType fromType, ResolvedType toType)
           
 void BcelCflowAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType)
           
 void TypeAnnotationAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType)
           
 void AnnotationAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType)
           
 void BcelVar.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)
           
 Var AnnotationAccessVar.getAccessorForValue(ResolvedType valueType)
          Return an object that can access a particular value of this annotation.
 Field LazyClassGen.getAnnotationCachingField(BcelShadow shadow, ResolvedType toType)
          Create a field in the type containing the shadow where the annotation retrieved during binding can be stored - for later fast access.
 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.
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 BcelCflowCounterFieldAdder.matches(ResolvedType onType)
           
 boolean BcelAccessForInlineMunger.matches(ResolvedType onType)
          Match only the aspect for which we act
 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 java.util.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 java.util.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 LazyClassGen.setSuperClass(ResolvedType newSuperclass)
           
 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
AnnotationAccessVar(BcelShadow shadow, Shadow.Kind kind, ResolvedType annotationType, UnresolvedType theTargetIsStoredHere, Member sig)
           
BcelAccessForInlineMunger(ResolvedType aspectType)
           
BcelAnnotation(AnnotationGen theBcelAnnotation, ResolvedType resolvedAnnotationType)
           
BcelCflowAccessVar(ResolvedType type, Member stackField, int index)
           
BcelFieldRef(ResolvedType type, java.lang.String className, java.lang.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
 ShadowMatch StandardPointcutExpressionImpl.matchesStaticInitialization(ResolvedType aType)
           
 

Uses of ResolvedType in org.aspectj.weaver.ltw
 

Methods in org.aspectj.weaver.ltw that return ResolvedType
 ResolvedType LTWWorld.resolve(java.lang.Class aClass)
           
 

Uses of ResolvedType in org.aspectj.weaver.model
 

Methods in org.aspectj.weaver.model with parameters of type ResolvedType
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
 

Methods in org.aspectj.weaver.patterns that return ResolvedType
 ResolvedType DeclareAnnotation.getAnnotationType()
           
 ResolvedType Declare.getDeclaringType()
           
 ResolvedType SimpleScope.getEnclosingType()
           
 ResolvedType ScopeWithTypeVariables.getEnclosingType()
           
 ResolvedType IScope.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
 java.util.List<ResolvedType> DeclareParents.findMatchingNewParents(ResolvedType onType, boolean reportErrors)
           
 

Methods in org.aspectj.weaver.patterns with parameters of type ResolvedType
 FuzzyBoolean TypePatternQuestions.askQuestion(TypePattern pattern, ResolvedType type, TypePattern.MatchKind kind)
           
 int DeclarePrecedence.compare(ResolvedType aspect1, ResolvedType aspect2)
           
 PerClause PerCflow.concretize(ResolvedType inAspect)
           
 PerClause PerFromSuper.concretize(ResolvedType inAspect)
           
 PerClause PerTypeWithin.concretize(ResolvedType inAspect)
           
abstract  PerClause PerClause.concretize(ResolvedType inAspect)
           
 PerClause PerSingleton.concretize(ResolvedType inAspect)
           
 PerClause PerObject.concretize(ResolvedType inAspect)
           
 Pointcut Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity)
          Returns a new pointcut Only used by test cases
 Pointcut Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
           
 Pointcut Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity, ShadowMunger advice)
           
 Pointcut NotPointcut.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 OrPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
           
 Pointcut ThisOrTargetPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
           
 Pointcut ArgsPointcut.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 PerClause.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
           
 Pointcut ReferencePointcut.concretize1(ResolvedType searchStart, ResolvedType declaringType, IntMap bindings)
           
 Pointcut WithincodePointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
           
 Pointcut WithinPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
           
 Pointcut AndPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
           
 Pointcut HandlerPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
           
 void DeclareAnnotation.copyAnnotationTo(ResolvedType onType)
           
 boolean OrSignaturePattern.couldEverMatch(ResolvedType type)
           
 boolean ISignaturePattern.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 AndSignaturePattern.couldEverMatch(ResolvedType type)
           
 boolean NotSignaturePattern.couldEverMatch(ResolvedType type)
           
 boolean SignaturePattern.couldEverMatch(ResolvedType type)
           
 boolean SignaturePattern.declaringTypeMatchAllowingForCovariance(Member member, UnresolvedType shadowDeclaringType, World world, TypePattern returnTypePattern, ResolvedType sigReturn)
           
 java.util.List<ResolvedType> DeclareParents.findMatchingNewParents(ResolvedType onType, boolean reportErrors)
           
 PerClause PerFromSuper.lookupConcretePerClause(ResolvedType lookupType)
           
 boolean DeclareParents.match(ResolvedType typeX)
           
abstract  FuzzyBoolean AnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean ExactAnnotationFieldTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean AnyAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean OrAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean WildAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean AndAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean BindingAnnotationFieldTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean ExactAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean NotAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
           
 FuzzyBoolean TypePatternList.matches(ResolvableTypeList types, TypePattern.MatchKind kind, ResolvedType[][] parameterAnnotations)
           
 boolean DeclareAnnotation.matches(ResolvedType type)
          For declare atType.
 FuzzyBoolean AnnotationPatternList.matches(ResolvedType[] someArgs)
           
 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 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 TypePattern.matches(ResolvedType type, TypePattern.MatchKind kind)
           
 FuzzyBoolean NotTypePattern.matchesInstanceof(ResolvedType type)
           
abstract  FuzzyBoolean TypePattern.matchesInstanceof(ResolvedType type)
           
 FuzzyBoolean WildTypePattern.matchesInstanceof(ResolvedType type)
           
 FuzzyBoolean OrTypePattern.matchesInstanceof(ResolvedType type)
           
 FuzzyBoolean TypeCategoryTypePattern.matchesInstanceof(ResolvedType type)
           
 FuzzyBoolean ExactTypePattern.matchesInstanceof(ResolvedType matchType)
           
 FuzzyBoolean HasMemberTypePattern.matchesInstanceof(ResolvedType type)
           
 FuzzyBoolean AndTypePattern.matchesInstanceof(ResolvedType type)
           
 boolean NotTypePattern.matchesStatically(ResolvedType type)
           
 boolean TypePattern.matchesStatically(ResolvedType type)
           
 boolean OrTypePattern.matchesStatically(ResolvedType type)
           
 boolean AndTypePattern.matchesStatically(ResolvedType type)
           
 void TypePattern.postRead(ResolvedType enclosingType)
           
 void Pointcut.postRead(ResolvedType enclosingType)
           
 void ThisOrTargetPointcut.postRead(ResolvedType enclosingType)
           
 void ArgsPointcut.postRead(ResolvedType enclosingType)
           
 void IfPointcut.IfFalsePointcut.postRead(ResolvedType enclosingType)
           
 void IfPointcut.IfTruePointcut.postRead(ResolvedType enclosingType)
           
 void KindedPointcut.postRead(ResolvedType enclosingType)
           
 void ReferencePointcut.postRead(ResolvedType enclosingType)
           
 void WithincodePointcut.postRead(ResolvedType enclosingType)
           
 void WithinPointcut.postRead(ResolvedType enclosingType)
           
 void SignaturePattern.postRead(ResolvedType enclosingType)
           
 void TypePatternList.postRead(ResolvedType enclosingType)
           
 void DeclareAnnotation.setAspect(ResolvedType typeX)
           
 void Declare.setDeclaringType(ResolvedType aType)
           
 

Constructors in org.aspectj.weaver.patterns with parameters of type ResolvedType
ConcreteCflowPointcut.Slot(int formalIndex, ResolvedType formalType, int arrayIndex)
           
ConcreteCflowPointcut(ResolvedType aspect, Member cflowField, java.util.List slots, boolean usesCounter)
           
FastMatchInfo(ResolvedType type, Shadow.Kind kind, World world)
           
PerThisOrTargetPointcutVisitor(boolean isTarget, ResolvedType fromAspectType)
           
TypePatternQuestions.Question(TypePattern pattern, ResolvedType type, TypePattern.MatchKind kind)
           
 

Uses of ResolvedType in org.aspectj.weaver.reflect
 

Fields in org.aspectj.weaver.reflect declared as ResolvedType
static ResolvedType[][] Java15AnnotationFinder.NO_PARAMETER_ANNOTATIONS
           
 

Methods in org.aspectj.weaver.reflect that return ResolvedType
 ResolvedType JavaLangTypeToResolvedTypeConverter.fromType(java.lang.reflect.Type aType)
           
 ResolvedType[] JavaLangTypeToResolvedTypeConverter.fromTypes(java.lang.reflect.Type[] types)
           
 ResolvedType[] Java15AnnotationFinder.getAnnotations(java.lang.Class forClass, World inWorld)
           
 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 ReflectionBasedReferenceTypeDelegate.getOuterClass()
           
 ResolvedType[][] ReflectionBasedResolvedMemberImpl.getParameterAnnotationTypes()
           
 ResolvedType[][] Java15AnnotationFinder.getParameterAnnotationTypes(java.lang.reflect.Member onMember)
           
 ResolvedType[][] AnnotationFinder.getParameterAnnotationTypes(java.lang.reflect.Member onMember)
           
 ResolvedType Java15ReflectionBasedReferenceTypeDelegate.getSuperclass()
           
 ResolvedType ReflectionBasedReferenceTypeDelegate.getSuperclass()
           
 ResolvedType ReflectionWorld.resolve(java.lang.Class aClass)
           
 ResolvedType IReflectionWorld.resolve(java.lang.Class aClass)
           
static ResolvedType ReflectionWorld.resolve(World world, java.lang.Class aClass)
           
static ResolvedType ReflectionBasedReferenceTypeDelegateFactory.resolveTypeInWorld(java.lang.Class aClass, World aWorld)
           
 

Methods in org.aspectj.weaver.reflect with parameters of type ResolvedType
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)
           
 java.lang.Object Java15AnnotationFinder.getAnnotation(ResolvedType annotationType, java.lang.Object onObject)
           
 java.lang.Object AnnotationFinder.getAnnotation(ResolvedType annotationType, java.lang.Object onObject)
           
 java.lang.Object Java15AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType, java.lang.Class aClass)
           
 java.lang.Object AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType, java.lang.Class aClass)
           
 java.lang.Object Java15AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType, java.lang.reflect.Member aMember)
           
 java.lang.Object AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType, java.lang.reflect.Member aMember)
           
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
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
 ShadowMatch StandardPointcutExpression.matchesStaticInitialization(ResolvedType aType)
          Determine whether or not this pointcut matches the static initialization of the given class.