From e4a3ab5cef0e9b37da2a1309b897d845f3cd1e51 Mon Sep 17 00:00:00 2001 From: aclement Date: Fri, 5 Sep 2008 17:06:08 +0000 Subject: [PATCH] 246125: comment 3: reworked AnnotationX - got rid of the thing --- .../reflect/Java15AnnotationFinder.java | 271 ++++++++++------- ...5ReflectionBasedReferenceTypeDelegate.java | 281 ++++++++++-------- 2 files changed, 329 insertions(+), 223 deletions(-) diff --git a/weaver5/java5-src/org/aspectj/weaver/reflect/Java15AnnotationFinder.java b/weaver5/java5-src/org/aspectj/weaver/reflect/Java15AnnotationFinder.java index 44e359d0b..e5ea78f3f 100644 --- a/weaver5/java5-src/org/aspectj/weaver/reflect/Java15AnnotationFinder.java +++ b/weaver5/java5-src/org/aspectj/weaver/reflect/Java15AnnotationFinder.java @@ -28,44 +28,51 @@ import org.aspectj.apache.bcel.classfile.LocalVariable; import org.aspectj.apache.bcel.classfile.LocalVariableTable; import org.aspectj.apache.bcel.util.NonCachingClassLoaderRepository; import org.aspectj.apache.bcel.util.Repository; -import org.aspectj.weaver.AnnotationX; +import org.aspectj.weaver.AnnotationAJ; import org.aspectj.weaver.ResolvedType; import org.aspectj.weaver.UnresolvedType; import org.aspectj.weaver.WeakClassLoaderReference; import org.aspectj.weaver.World; +import org.aspectj.weaver.bcel.BcelAnnotation; /** * Find the given annotation (if present) on the given object - * + * */ public class Java15AnnotationFinder implements AnnotationFinder, ArgNameFinder { - + private Repository bcelRepository; private WeakClassLoaderReference classLoaderRef; private World world; - + // must have no-arg constructor for reflective construction public Java15AnnotationFinder() { } - + public void setClassLoader(ClassLoader aLoader) { - // TODO: No easy way to ask the world factory for the right kind of repository so + // TODO: No easy way to ask the world factory for the right kind of + // repository so // default to the safe one! (pr160674) - this.classLoaderRef = new WeakClassLoaderReference(aLoader); - this.bcelRepository = new NonCachingClassLoaderRepository(classLoaderRef); + this.classLoaderRef = new WeakClassLoaderReference(aLoader); + this.bcelRepository = new NonCachingClassLoaderRepository( + classLoaderRef); } public void setWorld(World aWorld) { this.world = aWorld; } - - /* (non-Javadoc) - * @see org.aspectj.weaver.reflect.AnnotationFinder#getAnnotation(org.aspectj.weaver.ResolvedType, java.lang.Object) + + /* + * (non-Javadoc) + * + * @see + * org.aspectj.weaver.reflect.AnnotationFinder#getAnnotation(org.aspectj + * .weaver.ResolvedType, java.lang.Object) */ public Object getAnnotation(ResolvedType annotationType, Object onObject) { try { - Class annotationClass = (Class) Class.forName(annotationType.getName(), false, - getClassLoader()); + Class annotationClass = (Class) Class + .forName(annotationType.getName(), false, getClassLoader()); if (onObject.getClass().isAnnotationPresent(annotationClass)) { return onObject.getClass().getAnnotation(annotationClass); } @@ -75,9 +82,11 @@ public class Java15AnnotationFinder implements AnnotationFinder, ArgNameFinder { return null; } - public Object getAnnotationFromClass(ResolvedType annotationType, Class aClass) { + public Object getAnnotationFromClass(ResolvedType annotationType, + Class aClass) { try { - Class annotationClass = (Class) Class.forName(annotationType.getName(),false,getClassLoader()); + Class annotationClass = (Class) Class + .forName(annotationType.getName(), false, getClassLoader()); if (aClass.isAnnotationPresent(annotationClass)) { return aClass.getAnnotation(annotationClass); } @@ -86,12 +95,15 @@ public class Java15AnnotationFinder implements AnnotationFinder, ArgNameFinder { } return null; } - - public Object getAnnotationFromMember(ResolvedType annotationType, Member aMember) { - if (!(aMember instanceof AccessibleObject)) return null; + + public Object getAnnotationFromMember(ResolvedType annotationType, + Member aMember) { + if (!(aMember instanceof AccessibleObject)) + return null; AccessibleObject ao = (AccessibleObject) aMember; try { - Class annotationClass = Class.forName(annotationType.getName(),false,getClassLoader()); + Class annotationClass = Class.forName(annotationType.getName(), + false, getClassLoader()); if (ao.isAnnotationPresent(annotationClass)) { return ao.getAnnotation(annotationClass); } @@ -100,67 +112,84 @@ public class Java15AnnotationFinder implements AnnotationFinder, ArgNameFinder { } return null; } - + private ClassLoader getClassLoader() { return classLoaderRef.getClassLoader(); } - public AnnotationX getAnnotationOfType(UnresolvedType ofType,Member onMember) { - if (!(onMember instanceof AccessibleObject)) return null; - // here we really want both the runtime visible AND the class visible annotations - // so we bail out to Bcel and then chuck away the JavaClass so that we don't hog + public AnnotationAJ getAnnotationOfType(UnresolvedType ofType, + Member onMember) { + if (!(onMember instanceof AccessibleObject)) + return null; + // here we really want both the runtime visible AND the class visible + // annotations + // so we bail out to Bcel and then chuck away the JavaClass so that we + // don't hog // memory. try { - JavaClass jc = bcelRepository.loadClass(onMember.getDeclaringClass()); + JavaClass jc = bcelRepository.loadClass(onMember + .getDeclaringClass()); org.aspectj.apache.bcel.classfile.annotation.AnnotationGen[] anns = new org.aspectj.apache.bcel.classfile.annotation.AnnotationGen[0]; if (onMember instanceof Method) { - org.aspectj.apache.bcel.classfile.Method bcelMethod = jc.getMethod((Method)onMember); + org.aspectj.apache.bcel.classfile.Method bcelMethod = jc + .getMethod((Method) onMember); if (bcelMethod == null) { // pr220430 - //System.err.println("Unexpected problem in Java15AnnotationFinder: cannot retrieve annotations on method '"+onMember.getName()+"' in class '"+jc.getClassName()+"'"); + // System.err.println( + // "Unexpected problem in Java15AnnotationFinder: cannot retrieve annotations on method '" + // + + // onMember.getName()+"' in class '"+jc.getClassName()+"'"); } else { anns = bcelMethod.getAnnotations(); } } else if (onMember instanceof Constructor) { - org.aspectj.apache.bcel.classfile.Method bcelCons = jc.getMethod((Constructor)onMember); + org.aspectj.apache.bcel.classfile.Method bcelCons = jc + .getMethod((Constructor) onMember); anns = bcelCons.getAnnotations(); } else if (onMember instanceof Field) { - org.aspectj.apache.bcel.classfile.Field bcelField = jc.getField((Field)onMember); + org.aspectj.apache.bcel.classfile.Field bcelField = jc + .getField((Field) onMember); anns = bcelField.getAnnotations(); } // the answer is cached and we don't want to hold on to memory bcelRepository.clear(); // OPTIMIZE make constant 0 size array for sharing - if (anns == null) anns = new org.aspectj.apache.bcel.classfile.annotation.AnnotationGen[0]; + if (anns == null) + anns = new org.aspectj.apache.bcel.classfile.annotation.AnnotationGen[0]; // convert to our Annotation type - for (int i=0;i annSet = new HashSet(); for (int i = 0; i < anns.length; i++) { - annSet.add(world.resolve(UnresolvedType.forSignature(anns[i].getTypeSignature()))); + annSet.add(world.resolve(UnresolvedType.forSignature(anns[i] + .getTypeSignature()))); } return annSet; } catch (ClassNotFoundException cnfEx) { // just use reflection then } - - + AccessibleObject ao = (AccessibleObject) onMember; Annotation[] anns = ao.getDeclaredAnnotations(); Set annSet = new HashSet(); for (int i = 0; i < anns.length; i++) { - annSet.add(UnresolvedType.forName(anns[i].annotationType().getName()).resolve(world)); + annSet.add(UnresolvedType.forName( + anns[i].annotationType().getName()).resolve(world)); } return annSet; } - + public ResolvedType[] getAnnotations(Class forClass, World inWorld) { - // here we really want both the runtime visible AND the class visible annotations - // so we bail out to Bcel and then chuck away the JavaClass so that we don't hog + // here we really want both the runtime visible AND the class visible + // annotations + // so we bail out to Bcel and then chuck away the JavaClass so that we + // don't hog // memory. try { JavaClass jc = bcelRepository.loadClass(forClass); - org.aspectj.apache.bcel.classfile.annotation.AnnotationGen[] anns =jc.getAnnotations(); + org.aspectj.apache.bcel.classfile.annotation.AnnotationGen[] anns = jc + .getAnnotations(); bcelRepository.clear(); - if (anns == null) return new ResolvedType[0]; + if (anns == null) + return new ResolvedType[0]; ResolvedType[] ret = new ResolvedType[anns.length]; for (int i = 0; i < ret.length; i++) { - ret[i] = inWorld.resolve(UnresolvedType.forSignature(anns[i].getTypeSignature())); + ret[i] = inWorld.resolve(UnresolvedType.forSignature(anns[i] + .getTypeSignature())); } return ret; } catch (ClassNotFoundException cnfEx) { // just use reflection then } - + Annotation[] classAnnotations = forClass.getAnnotations(); ResolvedType[] ret = new ResolvedType[classAnnotations.length]; for (int i = 0; i < classAnnotations.length; i++) { - ret[i] = inWorld.resolve(classAnnotations[i].annotationType().getName()); + ret[i] = inWorld.resolve(classAnnotations[i].annotationType() + .getName()); } - + return ret; } - + public String[] getParameterNames(Member forMember) { - if (!(forMember instanceof AccessibleObject)) return null; - + if (!(forMember instanceof AccessibleObject)) + return null; + try { - JavaClass jc = bcelRepository.loadClass(forMember.getDeclaringClass()); + JavaClass jc = bcelRepository.loadClass(forMember + .getDeclaringClass()); LocalVariableTable lvt = null; int numVars = 0; if (forMember instanceof Method) { - org.aspectj.apache.bcel.classfile.Method bcelMethod = jc.getMethod((Method)forMember); + org.aspectj.apache.bcel.classfile.Method bcelMethod = jc + .getMethod((Method) forMember); lvt = bcelMethod.getLocalVariableTable(); numVars = bcelMethod.getArgumentTypes().length; } else if (forMember instanceof Constructor) { - org.aspectj.apache.bcel.classfile.Method bcelCons = jc.getMethod((Constructor)forMember); + org.aspectj.apache.bcel.classfile.Method bcelCons = jc + .getMethod((Constructor) forMember); lvt = bcelCons.getLocalVariableTable(); numVars = bcelCons.getArgumentTypes().length; } - return getParameterNamesFromLVT(lvt,numVars); + return getParameterNamesFromLVT(lvt, numVars); } catch (ClassNotFoundException cnfEx) { ; // no luck } - + return null; } - - private String[] getParameterNamesFromLVT(LocalVariableTable lvt, int numVars) { - if (lvt == null) - return null;// pr222987 - prevent NPE + + private String[] getParameterNamesFromLVT(LocalVariableTable lvt, + int numVars) { + if (lvt == null) + return null;// pr222987 - prevent NPE LocalVariable[] vars = lvt.getLocalVariableTable(); if (vars.length < numVars) { // basic error, we can't get the names... return null; } String[] ret = new String[numVars]; - for(int i = 0; i < numVars; i++) { - ret[i] = vars[i+1].getName(); + for (int i = 0; i < numVars; i++) { + ret[i] = vars[i + 1].getName(); } return ret; } - public static final ResolvedType[][] NO_PARAMETER_ANNOTATIONS = new ResolvedType[][]{}; - + + public static final ResolvedType[][] NO_PARAMETER_ANNOTATIONS = new ResolvedType[][] {}; + public ResolvedType[][] getParameterAnnotationTypes(Member onMember) { - if (!(onMember instanceof AccessibleObject)) return NO_PARAMETER_ANNOTATIONS; - // here we really want both the runtime visible AND the class visible annotations - // so we bail out to Bcel and then chuck away the JavaClass so that we don't hog + if (!(onMember instanceof AccessibleObject)) + return NO_PARAMETER_ANNOTATIONS; + // here we really want both the runtime visible AND the class visible + // annotations + // so we bail out to Bcel and then chuck away the JavaClass so that we + // don't hog // memory. try { - JavaClass jc = bcelRepository.loadClass(onMember.getDeclaringClass()); + JavaClass jc = bcelRepository.loadClass(onMember + .getDeclaringClass()); org.aspectj.apache.bcel.classfile.annotation.AnnotationGen[][] anns = null; if (onMember instanceof Method) { - org.aspectj.apache.bcel.classfile.Method bcelMethod = jc.getMethod((Method)onMember); + org.aspectj.apache.bcel.classfile.Method bcelMethod = jc + .getMethod((Method) onMember); if (bcelMethod == null) { // pr220430 - //System.err.println("Unexpected problem in Java15AnnotationFinder: cannot retrieve annotations on method '"+onMember.getName()+"' in class '"+jc.getClassName()+"'"); + // System.err.println( + // "Unexpected problem in Java15AnnotationFinder: cannot retrieve annotations on method '" + // + + // onMember.getName()+"' in class '"+jc.getClassName()+"'"); } else { anns = bcelMethod.getParameterAnnotations(); } } else if (onMember instanceof Constructor) { - org.aspectj.apache.bcel.classfile.Method bcelCons = jc.getMethod((Constructor)onMember); + org.aspectj.apache.bcel.classfile.Method bcelCons = jc + .getMethod((Constructor) onMember); anns = bcelCons.getParameterAnnotations(); } else if (onMember instanceof Field) { -// anns = null; + // anns = null; } // the answer is cached and we don't want to hold on to memory bcelRepository.clear(); - if (anns == null) return NO_PARAMETER_ANNOTATIONS; + if (anns == null) + return NO_PARAMETER_ANNOTATIONS; ResolvedType[][] result = new ResolvedType[anns.length][]; // CACHING?? - for (int i=0;i myType; private ResolvedType[] annotations; private ResolvedMember[] pointcuts; @@ -56,38 +55,42 @@ public class Java15ReflectionBasedReferenceTypeDelegate extends private JavaLangTypeToResolvedTypeConverter typeConverter; private Java15AnnotationFinder annotationFinder = null; private ArgNameFinder argNameFinder = null; - - public Java15ReflectionBasedReferenceTypeDelegate() {} - + public Java15ReflectionBasedReferenceTypeDelegate() { + } + @Override - public void initialize(ReferenceType aType, Class aClass, ClassLoader classLoader, World aWorld) { + public void initialize(ReferenceType aType, Class aClass, + ClassLoader classLoader, World aWorld) { super.initialize(aType, aClass, classLoader, aWorld); myType = AjTypeSystem.getAjType(aClass); annotationFinder = new Java15AnnotationFinder(); argNameFinder = annotationFinder; - annotationFinder.setClassLoader(this.classLoaderReference.getClassLoader()); + annotationFinder.setClassLoader(this.classLoaderReference + .getClassLoader()); annotationFinder.setWorld(aWorld); this.typeConverter = new JavaLangTypeToResolvedTypeConverter(aWorld); } - - + public ReferenceType buildGenericType() { - return (ReferenceType) UnresolvedType.forGenericTypeVariables( - getResolvedTypeX().getSignature(), - getTypeVariables()).resolve(getWorld()); + return (ReferenceType) UnresolvedType.forGenericTypeVariables( + getResolvedTypeX().getSignature(), getTypeVariables()).resolve( + getWorld()); } - - public AnnotationX[] getAnnotations() { + + public AnnotationAJ[] getAnnotations() { // AMC - we seem not to need to implement this method... - //throw new UnsupportedOperationException("getAnnotations on Java15ReflectionBasedReferenceTypeDelegate is not implemented yet"); - // FIXME is this the right implementation in the reflective case? + // throw new UnsupportedOperationException( + // "getAnnotations on Java15ReflectionBasedReferenceTypeDelegate is not implemented yet" + // ); + // FIXME is this the right implementation in the reflective case? return super.getAnnotations(); } - + public ResolvedType[] getAnnotationTypes() { if (annotations == null) { - annotations = annotationFinder.getAnnotations(getBaseClass(), getWorld()); + annotations = annotationFinder.getAnnotations(getBaseClass(), + getWorld()); } return annotations; } @@ -96,11 +99,12 @@ public class Java15ReflectionBasedReferenceTypeDelegate extends ResolvedType[] myAnns = getAnnotationTypes(); ResolvedType toLookFor = ofType.resolve(getWorld()); for (int i = 0; i < myAnns.length; i++) { - if (myAnns[i] == toLookFor) return true; + if (myAnns[i] == toLookFor) + return true; } return false; } - + // use the MAP to ensure that any aj-synthetic fields are filtered out public ResolvedMember[] getDeclaredFields() { if (fields == null) { @@ -113,14 +117,14 @@ public class Java15ReflectionBasedReferenceTypeDelegate extends } return fields; } - + public String getDeclaredGenericSignature() { if (this.genericSignature == null && isGeneric()) { - + } return genericSignature; } - + public ResolvedType[] getDeclaredInterfaces() { if (superInterfaces == null) { Type[] genericInterfaces = getBaseClass().getGenericInterfaces(); @@ -128,45 +132,58 @@ public class Java15ReflectionBasedReferenceTypeDelegate extends } return superInterfaces; } - + // If the superclass is null, return Object - same as bcel does public ResolvedType getSuperclass() { - if (superclass == null && getBaseClass()!=Object.class) {// superclass of Object is null - Type t = this.getBaseClass().getGenericSuperclass(); - if (t!=null) superclass = typeConverter.fromType(t); - if (t==null) superclass = getWorld().resolve(UnresolvedType.OBJECT); + if (superclass == null && getBaseClass() != Object.class) {// superclass + // of Object + // is null + Type t = this.getBaseClass().getGenericSuperclass(); + if (t != null) + superclass = typeConverter.fromType(t); + if (t == null) + superclass = getWorld().resolve(UnresolvedType.OBJECT); } - return superclass; + return superclass; } - + public TypeVariable[] getTypeVariables() { - TypeVariable[] workInProgressSetOfVariables = (TypeVariable[])getResolvedTypeX().getWorld().getTypeVariablesCurrentlyBeingProcessed(getBaseClass()); - if (workInProgressSetOfVariables!=null) { + TypeVariable[] workInProgressSetOfVariables = (TypeVariable[]) getResolvedTypeX() + .getWorld().getTypeVariablesCurrentlyBeingProcessed( + getBaseClass()); + if (workInProgressSetOfVariables != null) { return workInProgressSetOfVariables; } if (this.typeVariables == null) { - java.lang.reflect.TypeVariable[] tVars = this.getBaseClass().getTypeParameters(); + java.lang.reflect.TypeVariable[] tVars = this.getBaseClass() + .getTypeParameters(); TypeVariable[] rTypeVariables = new TypeVariable[tVars.length]; // basic initialization for (int i = 0; i < tVars.length; i++) { - rTypeVariables[i] = new TypeVariable(tVars[i].getName()); + rTypeVariables[i] = new TypeVariable(tVars[i].getName()); } // stash it - this.getResolvedTypeX().getWorld().recordTypeVariablesCurrentlyBeingProcessed(getBaseClass(), rTypeVariables); + this.getResolvedTypeX().getWorld() + .recordTypeVariablesCurrentlyBeingProcessed(getBaseClass(), + rTypeVariables); // now fill in the details... for (int i = 0; i < tVars.length; i++) { - TypeVariableReferenceType tvrt = ((TypeVariableReferenceType) typeConverter.fromType(tVars[i])); + TypeVariableReferenceType tvrt = ((TypeVariableReferenceType) typeConverter + .fromType(tVars[i])); TypeVariable tv = tvrt.getTypeVariable(); rTypeVariables[i].setUpperBound(tv.getUpperBound()); - rTypeVariables[i].setAdditionalInterfaceBounds(tv.getAdditionalInterfaceBounds()); - rTypeVariables[i].setDeclaringElement(tv.getDeclaringElement()); - rTypeVariables[i].setDeclaringElementKind(tv.getDeclaringElementKind()); - rTypeVariables[i].setRank(tv.getRank()); - rTypeVariables[i].setLowerBound(tv.getLowerBound()); + rTypeVariables[i].setAdditionalInterfaceBounds(tv + .getAdditionalInterfaceBounds()); + rTypeVariables[i].setDeclaringElement(tv.getDeclaringElement()); + rTypeVariables[i].setDeclaringElementKind(tv + .getDeclaringElementKind()); + rTypeVariables[i].setRank(tv.getRank()); + rTypeVariables[i].setLowerBound(tv.getLowerBound()); } this.typeVariables = rTypeVariables; - this.getResolvedTypeX().getWorld().forgetTypeVariablesCurrentlyBeingProcessed(getBaseClass()); - } + this.getResolvedTypeX().getWorld() + .forgetTypeVariablesCurrentlyBeingProcessed(getBaseClass()); + } return this.typeVariables; } @@ -176,73 +193,73 @@ public class Java15ReflectionBasedReferenceTypeDelegate extends if (methods == null) { Method[] reflectMethods = this.myType.getDeclaredMethods(); Constructor[] reflectCons = this.myType.getDeclaredConstructors(); - ResolvedMember[] rMethods = new ResolvedMember[reflectMethods.length + reflectCons.length]; + ResolvedMember[] rMethods = new ResolvedMember[reflectMethods.length + + reflectCons.length]; for (int i = 0; i < reflectMethods.length; i++) { - rMethods[i] = createGenericMethodMember(reflectMethods[i]); + rMethods[i] = createGenericMethodMember(reflectMethods[i]); } for (int i = 0; i < reflectCons.length; i++) { - rMethods[i + reflectMethods.length] = - createGenericConstructorMember(reflectCons[i]); + rMethods[i + reflectMethods.length] = createGenericConstructorMember(reflectCons[i]); } this.methods = rMethods; } return methods; } - + /** * Returns the generic type, regardless of the resolvedType we 'know about' */ public ResolvedType getGenericResolvedType() { ResolvedType rt = getResolvedTypeX(); - if (rt.isParameterizedType() || rt.isRawType()) return rt.getGenericType(); + if (rt.isParameterizedType() || rt.isRawType()) + return rt.getGenericType(); return rt; } - + private ResolvedMember createGenericMethodMember(Method forMethod) { - ReflectionBasedResolvedMemberImpl ret = - new ReflectionBasedResolvedMemberImpl(org.aspectj.weaver.Member.METHOD, - getGenericResolvedType(), - forMethod.getModifiers(), - typeConverter.fromType(forMethod.getReturnType()), - forMethod.getName(), - typeConverter.fromTypes(forMethod.getParameterTypes()), - typeConverter.fromTypes(forMethod.getExceptionTypes()), - forMethod - ); + ReflectionBasedResolvedMemberImpl ret = new ReflectionBasedResolvedMemberImpl( + org.aspectj.weaver.Member.METHOD, getGenericResolvedType(), + forMethod.getModifiers(), typeConverter.fromType(forMethod + .getReturnType()), forMethod.getName(), typeConverter + .fromTypes(forMethod.getParameterTypes()), + typeConverter.fromTypes(forMethod.getExceptionTypes()), + forMethod); ret.setAnnotationFinder(this.annotationFinder); - ret.setGenericSignatureInformationProvider(new Java15GenericSignatureInformationProvider(this.getWorld())); + ret + .setGenericSignatureInformationProvider(new Java15GenericSignatureInformationProvider( + this.getWorld())); return ret; } - private ResolvedMember createGenericConstructorMember(Constructor forConstructor) { - ReflectionBasedResolvedMemberImpl ret = - new ReflectionBasedResolvedMemberImpl(org.aspectj.weaver.Member.METHOD, - getGenericResolvedType(), - forConstructor.getModifiers(), - // to return what BCEL returns the return type is void - ResolvedType.VOID,//getGenericResolvedType(), - "", - typeConverter.fromTypes(forConstructor.getParameterTypes()), - typeConverter.fromTypes(forConstructor.getExceptionTypes()), - forConstructor - ); + private ResolvedMember createGenericConstructorMember( + Constructor forConstructor) { + ReflectionBasedResolvedMemberImpl ret = new ReflectionBasedResolvedMemberImpl( + org.aspectj.weaver.Member.METHOD, + getGenericResolvedType(), + forConstructor.getModifiers(), + // to return what BCEL returns the return type is void + ResolvedType.VOID,// getGenericResolvedType(), + "", typeConverter.fromTypes(forConstructor + .getParameterTypes()), typeConverter + .fromTypes(forConstructor.getExceptionTypes()), + forConstructor); ret.setAnnotationFinder(this.annotationFinder); - ret.setGenericSignatureInformationProvider(new Java15GenericSignatureInformationProvider(this.getWorld())); + ret + .setGenericSignatureInformationProvider(new Java15GenericSignatureInformationProvider( + this.getWorld())); return ret; } - + private ResolvedMember createGenericFieldMember(Field forField) { - ReflectionBasedResolvedMemberImpl ret = - new ReflectionBasedResolvedMemberImpl( - org.aspectj.weaver.Member.FIELD, - getGenericResolvedType(), - forField.getModifiers(), - typeConverter.fromType(forField.getType()), - forField.getName(), - new UnresolvedType[0], + ReflectionBasedResolvedMemberImpl ret = new ReflectionBasedResolvedMemberImpl( + org.aspectj.weaver.Member.FIELD, getGenericResolvedType(), + forField.getModifiers(), typeConverter.fromType(forField + .getType()), forField.getName(), new UnresolvedType[0], forField); ret.setAnnotationFinder(this.annotationFinder); - ret.setGenericSignatureInformationProvider(new Java15GenericSignatureInformationProvider(this.getWorld())); + ret + .setGenericSignatureInformationProvider(new Java15GenericSignatureInformationProvider( + this.getWorld())); return ret; } @@ -253,27 +270,38 @@ public class Java15ReflectionBasedReferenceTypeDelegate extends InternalUseOnlyPointcutParser parser = null; World world = getWorld(); if (world instanceof ReflectionWorld) { - parser = new InternalUseOnlyPointcutParser(classLoaderReference.getClassLoader(), (ReflectionWorld) getWorld()); + parser = new InternalUseOnlyPointcutParser(classLoaderReference + .getClassLoader(), (ReflectionWorld) getWorld()); } else { - parser = new InternalUseOnlyPointcutParser(classLoaderReference.getClassLoader()); + parser = new InternalUseOnlyPointcutParser(classLoaderReference + .getClassLoader()); + } + Set additionalPointcutHandlers = world + .getRegisteredPointcutHandlers(); + for (Iterator handlerIterator = additionalPointcutHandlers + .iterator(); handlerIterator.hasNext();) { + PointcutDesignatorHandler handler = (PointcutDesignatorHandler) handlerIterator + .next(); + parser.registerPointcutDesignatorHandler(handler); } - Set additionalPointcutHandlers = world.getRegisteredPointcutHandlers(); - for (Iterator handlerIterator = additionalPointcutHandlers.iterator(); handlerIterator.hasNext();) { - PointcutDesignatorHandler handler = (PointcutDesignatorHandler) handlerIterator.next(); - parser.registerPointcutDesignatorHandler(handler); - } - - // phase 1, create legitimate entries in pointcuts[] before we attempt to resolve *any* of the pointcuts - // resolution can sometimes cause us to recurse, and this two stage process allows us to cope with that + + // phase 1, create legitimate entries in pointcuts[] before we + // attempt to resolve *any* of the pointcuts + // resolution can sometimes cause us to recurse, and this two stage + // process allows us to cope with that for (int i = 0; i < pcs.length; i++) { AjType[] ptypes = pcs[i].getParameterTypes(); UnresolvedType[] weaverPTypes = new UnresolvedType[ptypes.length]; for (int j = 0; j < weaverPTypes.length; j++) { - weaverPTypes[j] = this.typeConverter.fromType(ptypes[j].getJavaClass()) ; + weaverPTypes[j] = this.typeConverter.fromType(ptypes[j] + .getJavaClass()); } - pointcuts[i] = new DeferredResolvedPointcutDefinition(getResolvedTypeX(),pcs[i].getModifiers(),pcs[i].getName(),weaverPTypes); + pointcuts[i] = new DeferredResolvedPointcutDefinition( + getResolvedTypeX(), pcs[i].getModifiers(), pcs[i] + .getName(), weaverPTypes); } - // phase 2, now go back round and resolve in-place all of the pointcuts + // phase 2, now go back round and resolve in-place all of the + // pointcuts PointcutParameter[][] parameters = new PointcutParameter[pcs.length][]; for (int i = 0; i < pcs.length; i++) { AjType[] ptypes = pcs[i].getParameterTypes(); @@ -281,73 +309,84 @@ public class Java15ReflectionBasedReferenceTypeDelegate extends if (pnames.length != ptypes.length) { pnames = tryToDiscoverParameterNames(pcs[i]); if (pnames == null || (pnames.length != ptypes.length)) { - throw new IllegalStateException("Required parameter names not available when parsing pointcut " + pcs[i].getName() + " in type " + getResolvedTypeX().getName()); + throw new IllegalStateException( + "Required parameter names not available when parsing pointcut " + + pcs[i].getName() + " in type " + + getResolvedTypeX().getName()); } } parameters[i] = new PointcutParameter[ptypes.length]; for (int j = 0; j < parameters[i].length; j++) { - parameters[i][j] = parser.createPointcutParameter(pnames[j],ptypes[j].getJavaClass()); - } String pcExpr = pcs[i].getPointcutExpression().toString(); - org.aspectj.weaver.patterns.Pointcut pc = parser.resolvePointcutExpression(pcExpr,getBaseClass(),parameters[i]); - ((ResolvedPointcutDefinition)pointcuts[i]).setParameterNames(pnames); - ((ResolvedPointcutDefinition)pointcuts[i]).setPointcut(pc); + parameters[i][j] = parser.createPointcutParameter( + pnames[j], ptypes[j].getJavaClass()); + } + String pcExpr = pcs[i].getPointcutExpression().toString(); + org.aspectj.weaver.patterns.Pointcut pc = parser + .resolvePointcutExpression(pcExpr, getBaseClass(), + parameters[i]); + ((ResolvedPointcutDefinition) pointcuts[i]) + .setParameterNames(pnames); + ((ResolvedPointcutDefinition) pointcuts[i]).setPointcut(pc); } // phase 3, now concretize them all for (int i = 0; i < pointcuts.length; i++) { ResolvedPointcutDefinition rpd = (ResolvedPointcutDefinition) pointcuts[i]; - rpd.setPointcut(parser.concretizePointcutExpression(rpd.getPointcut(), getBaseClass(), parameters[i])); + rpd.setPointcut(parser.concretizePointcutExpression(rpd + .getPointcut(), getBaseClass(), parameters[i])); } } return pointcuts; } - + // for @AspectJ pointcuts compiled by javac only... private String[] tryToDiscoverParameterNames(Pointcut pcut) { - Method[] ms = pcut.getDeclaringType().getJavaClass().getDeclaredMethods(); - for(Method m : ms) { + Method[] ms = pcut.getDeclaringType().getJavaClass() + .getDeclaredMethods(); + for (Method m : ms) { if (m.getName().equals(pcut.getName())) { return argNameFinder.getParameterNames(m); } } return null; } - + public boolean isAnnotation() { return getBaseClass().isAnnotation(); } - + public boolean isAnnotationStyleAspect() { return getBaseClass().isAnnotationPresent(Aspect.class); } - + public boolean isAnnotationWithRuntimeRetention() { - if (!isAnnotation()) return false; + if (!isAnnotation()) + return false; if (getBaseClass().isAnnotationPresent(Retention.class)) { - Retention retention = (Retention) getBaseClass().getAnnotation(Retention.class); + Retention retention = (Retention) getBaseClass().getAnnotation( + Retention.class); RetentionPolicy policy = retention.value(); return policy == RetentionPolicy.RUNTIME; } else { return false; } } - + public boolean isAspect() { return this.myType.isAspect(); } - + public boolean isEnum() { return getBaseClass().isEnum(); } - + public boolean isGeneric() { - //return false; // for now + // return false; // for now return getBaseClass().getTypeParameters().length > 0; } @Override - public boolean isAnonymous() { + public boolean isAnonymous() { return this.myClass.isAnonymousClass(); } } - -- 2.39.5