/* ******************************************************************* * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC). * All rights reserved. * This program and the accompanying materials are made available * under the terms of the Common Public License v1.0 * which accompanies this distribution and is available at * http://www.eclipse.org/legal/cpl-v10.html * * Contributors: * PARC initial implementation * ******************************************************************/ package org.aspectj.weaver; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import java.lang.reflect.Modifier; //import org.aspectj.weaver.ResolvedType.Name; public class AjcMemberMaker { private static final int PUBLIC_STATIC_FINAL = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL; private static final int PRIVATE_STATIC = Modifier.PRIVATE | Modifier.STATIC; private static final int PUBLIC_STATIC = Modifier.PUBLIC | Modifier.STATIC; private static final int VISIBILITY = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED; public static final UnresolvedType CFLOW_STACK_TYPE = UnresolvedType.forName(NameMangler.CFLOW_STACK_TYPE); public static final UnresolvedType AROUND_CLOSURE_TYPE = UnresolvedType.forName("org.aspectj.runtime.internal.AroundClosure"); public static final UnresolvedType CONVERSIONS_TYPE = UnresolvedType.forName("org.aspectj.runtime.internal.Conversions"); public static final UnresolvedType NO_ASPECT_BOUND_EXCEPTION = UnresolvedType.forName("org.aspectj.lang.NoAspectBoundException"); public static ResolvedMember ajcPreClinitMethod(UnresolvedType declaringType) { return new ResolvedMemberImpl( Member.METHOD, declaringType, PRIVATE_STATIC, NameMangler.AJC_PRE_CLINIT_NAME, "()V"); } public static ResolvedMember ajcPostClinitMethod(UnresolvedType declaringType) { return new ResolvedMemberImpl( Member.METHOD, declaringType, PRIVATE_STATIC, NameMangler.AJC_POST_CLINIT_NAME, "()V"); } public static Member noAspectBoundExceptionInit() { return new ResolvedMemberImpl( Member.METHOD, NO_ASPECT_BOUND_EXCEPTION, Modifier.PUBLIC, "", "()V"); } public static Member noAspectBoundExceptionInit2() { return new ResolvedMemberImpl( Member.METHOD, NO_ASPECT_BOUND_EXCEPTION, Modifier.PUBLIC, "", "(Ljava/lang/String;Ljava/lang/Throwable;)V"); } public static Member noAspectBoundExceptionInitWithCause() { return new ResolvedMemberImpl( Member.METHOD, NO_ASPECT_BOUND_EXCEPTION, Modifier.PUBLIC, "", "(Ljava/lang/String;Ljava/lang/Throwable;)V"); } public static ResolvedMember perCflowPush(UnresolvedType declaringType) { return new ResolvedMemberImpl( Member.METHOD, declaringType, PUBLIC_STATIC, NameMangler.PERCFLOW_PUSH_METHOD, "()V"); } public static ResolvedMember perCflowField(UnresolvedType declaringType) { return new ResolvedMemberImpl( Member.FIELD, declaringType, PUBLIC_STATIC_FINAL, NameMangler.PERCFLOW_FIELD_NAME, CFLOW_STACK_TYPE.getSignature()); } public static ResolvedMember perSingletonField(UnresolvedType declaringType) { return new ResolvedMemberImpl( Member.FIELD, declaringType, PUBLIC_STATIC_FINAL, NameMangler.PERSINGLETON_FIELD_NAME, declaringType.getSignature()); } public static ResolvedMember initFailureCauseField(UnresolvedType declaringType) { return new ResolvedMemberImpl( Member.FIELD, declaringType, PRIVATE_STATIC, NameMangler.INITFAILURECAUSE_FIELD_NAME, UnresolvedType.THROWABLE.getSignature()); } public static ResolvedMember perObjectField(UnresolvedType declaringType, ResolvedType aspectType) { int modifiers = Modifier.PRIVATE; if (!UnresolvedType.SERIALIZABLE.resolve(aspectType.getWorld()).isAssignableFrom(aspectType)) { modifiers |= Modifier.TRANSIENT; } return new ResolvedMemberImpl( Member.FIELD, declaringType, modifiers, aspectType, NameMangler.perObjectInterfaceField(aspectType), UnresolvedType.NONE); } // PTWIMPL ResolvedMember for aspect instance field, declared in matched type public static ResolvedMember perTypeWithinField(UnresolvedType declaringType, ResolvedType aspectType) { int modifiers = Modifier.PRIVATE | Modifier.STATIC; if (!isSerializableAspect(aspectType)) { modifiers |= Modifier.TRANSIENT; } return new ResolvedMemberImpl(Member.FIELD, declaringType, modifiers, aspectType, NameMangler.perTypeWithinFieldForTarget(aspectType), UnresolvedType.NONE); } // PTWIMPL ResolvedMember for type instance field, declared in aspect // (holds typename for which aspect instance exists) public static ResolvedMember perTypeWithinWithinTypeField(UnresolvedType declaringType, ResolvedType aspectType) { int modifiers = Modifier.PRIVATE; if (!isSerializableAspect(aspectType)) { modifiers |= Modifier.TRANSIENT; } return new ResolvedMemberImpl(Member.FIELD, declaringType, modifiers, UnresolvedType.forSignature("Ljava/lang/String;"), NameMangler.PERTYPEWITHIN_WITHINTYPEFIELD, UnresolvedType.NONE); } private static boolean isSerializableAspect(ResolvedType aspectType) { return UnresolvedType.SERIALIZABLE.resolve(aspectType.getWorld()).isAssignableFrom(aspectType); } public static ResolvedMember perObjectBind(UnresolvedType declaringType) { return new ResolvedMemberImpl( Member.METHOD, declaringType, PUBLIC_STATIC, NameMangler.PEROBJECT_BIND_METHOD, "(Ljava/lang/Object;)V"); } // PTWIMPL ResolvedMember for getInstance() method, declared in aspect public static ResolvedMember perTypeWithinGetInstance(UnresolvedType declaringType) { // private static a.X ajc$getInstance(java.lang.Class) ResolvedMemberImpl rm = new ResolvedMemberImpl( Member.METHOD, declaringType, PRIVATE_STATIC, declaringType, // return value NameMangler.PERTYPEWITHIN_GETINSTANCE_METHOD, new UnresolvedType[]{UnresolvedType.JAVA_LANG_CLASS} ); return rm; } public static ResolvedMember perTypeWithinCreateAspectInstance(UnresolvedType declaringType) { // public static a.X ajc$createAspectInstance(java.lang.String) ResolvedMemberImpl rm = new ResolvedMemberImpl( Member.METHOD, declaringType, PUBLIC_STATIC, declaringType, // return value NameMangler.PERTYPEWITHIN_CREATEASPECTINSTANCE_METHOD, new UnresolvedType[]{UnresolvedType.forSignature("Ljava/lang/String;")},new UnresolvedType[]{} ); return rm; } public static UnresolvedType perObjectInterfaceType(UnresolvedType aspectType) { return UnresolvedType.forName(aspectType.getName()+"$ajcMightHaveAspect"); } public static ResolvedMember perObjectInterfaceGet(UnresolvedType aspectType) { return new ResolvedMemberImpl( Member.METHOD, perObjectInterfaceType(aspectType), Modifier.PUBLIC | Modifier.ABSTRACT, NameMangler.perObjectInterfaceGet(aspectType), "()" + aspectType.getSignature()); } public static ResolvedMember perObjectInterfaceSet(UnresolvedType aspectType) { return new ResolvedMemberImpl( Member.METHOD, perObjectInterfaceType(aspectType), Modifier.PUBLIC | Modifier.ABSTRACT, NameMangler.perObjectInterfaceSet(aspectType), "(" + aspectType.getSignature() + ")V"); } // PTWIMPL ResolvedMember for localAspectOf() method, declared in matched type public static ResolvedMember perTypeWithinLocalAspectOf(UnresolvedType shadowType,UnresolvedType aspectType) { return new ResolvedMemberImpl( Member.METHOD, shadowType,//perTypeWithinInterfaceType(aspectType), Modifier.PUBLIC | Modifier.STATIC, NameMangler.perTypeWithinLocalAspectOf(aspectType), "()" + aspectType.getSignature()); } public static ResolvedMember perSingletonAspectOfMethod(UnresolvedType declaringType) { return new ResolvedMemberImpl(Member.METHOD, declaringType, PUBLIC_STATIC, "aspectOf", "()" + declaringType.getSignature()); } public static ResolvedMember perSingletonHasAspectMethod(UnresolvedType declaringType) { return new ResolvedMemberImpl(Member.METHOD, declaringType, PUBLIC_STATIC, "hasAspect", "()Z"); }; public static ResolvedMember perCflowAspectOfMethod(UnresolvedType declaringType) { return perSingletonAspectOfMethod(declaringType); } public static ResolvedMember perCflowHasAspectMethod(UnresolvedType declaringType) { return perSingletonHasAspectMethod(declaringType); }; public static ResolvedMember perObjectAspectOfMethod(UnresolvedType declaringType) { return new ResolvedMemberImpl(Member.METHOD, declaringType, PUBLIC_STATIC, "aspectOf", "(Ljava/lang/Object;)" + declaringType.getSignature()); } public static ResolvedMember perObjectHasAspectMethod(UnresolvedType declaringType) { return new ResolvedMemberImpl(Member.METHOD, declaringType, PUBLIC_STATIC, "hasAspect", "(Ljava/lang/Object;)Z"); }; // PTWIMPL ResolvedMember for aspectOf(), declared in aspect public static ResolvedMember perTypeWithinAspectOfMethod(UnresolvedType declaringType,boolean inJava5Mode) { UnresolvedType parameterType = null; if (inJava5Mode) { parameterType = UnresolvedType.forRawTypeName("java.lang.Class"); } else { parameterType = UnresolvedType.forSignature("Ljava/lang/Class;"); } return new ResolvedMemberImpl( Member.METHOD, declaringType, PUBLIC_STATIC, declaringType, "aspectOf", new UnresolvedType[] {parameterType} ); // return new ResolvedMemberImpl(Member.METHOD, // declaringType, PUBLIC_STATIC, "aspectOf", // "(Ljava/lang/Class;)" + declaringType.getSignature()); } // PTWIMPL ResolvedMember for hasAspect(), declared in aspect public static ResolvedMember perTypeWithinHasAspectMethod(UnresolvedType declaringType, boolean inJava5Mode) { UnresolvedType parameterType = null; if (inJava5Mode) { parameterType = UnresolvedType.forRawTypeName("java.lang.Class"); } else { parameterType = UnresolvedType.forSignature("Ljava/lang/Class;"); } return new ResolvedMemberImpl( Member.METHOD, declaringType, PUBLIC_STATIC, ResolvedType.BOOLEAN, "hasAspect", new UnresolvedType[] {parameterType} ); // return new ResolvedMemberImpl(Member.METHOD, // declaringType, PUBLIC_STATIC, "hasAspect", // "(Ljava/lang/Class;)Z"); }; // -- privileged accessors public static ResolvedMember privilegedAccessMethodForMethod(UnresolvedType aspectType, ResolvedMember method) { return new ResolvedMemberImpl( Member.METHOD, method.getDeclaringType(), Modifier.PUBLIC | (method.isStatic() ? Modifier.STATIC : 0), method.getReturnType(), NameMangler.privilegedAccessMethodForMethod(method.getName(),method.getDeclaringType(), aspectType), method.getParameterTypes(), method.getExceptions()); } public static ResolvedMember privilegedAccessMethodForFieldGet(UnresolvedType aspectType, Member field) { String sig; if (field.isStatic()) { sig = "()" + field.getReturnType().getSignature(); } else { sig = "(" + field.getDeclaringType().getSignature() + ")" + field.getReturnType().getSignature(); } return new ResolvedMemberImpl(Member.METHOD, field.getDeclaringType(), PUBLIC_STATIC, //Modifier.PUBLIC | (field.isStatic() ? Modifier.STATIC : 0), NameMangler.privilegedAccessMethodForFieldGet(field.getName(), field.getDeclaringType(), aspectType), sig); } public static ResolvedMember privilegedAccessMethodForFieldSet(UnresolvedType aspectType, Member field) { String sig; if (field.isStatic()) { sig = "(" + field.getReturnType().getSignature() + ")V"; } else { sig = "(" + field.getDeclaringType().getSignature() + field.getReturnType().getSignature() + ")V"; } return new ResolvedMemberImpl(Member.METHOD, field.getDeclaringType(), PUBLIC_STATIC, //Modifier.PUBLIC | (field.isStatic() ? Modifier.STATIC : 0), NameMangler.privilegedAccessMethodForFieldSet(field.getName(), field.getDeclaringType(), aspectType), sig); } // --- inline accessors //??? can eclipse handle a transform this weird without putting synthetics into the mix public static ResolvedMember superAccessMethod(UnresolvedType baseType, ResolvedMember method) { return new ResolvedMemberImpl(Member.METHOD, baseType, Modifier.PUBLIC, method.getReturnType(), NameMangler.superDispatchMethod(baseType, method.getName()), method.getParameterTypes(), method.getExceptions()); } public static ResolvedMember inlineAccessMethodForMethod(UnresolvedType aspectType, ResolvedMember method) { UnresolvedType[] paramTypes = method.getParameterTypes(); if (!method.isStatic()) { paramTypes = UnresolvedType.insert(method.getDeclaringType(), paramTypes); } return new ResolvedMemberImpl(Member.METHOD, aspectType, PUBLIC_STATIC, //??? what about privileged and super access //???Modifier.PUBLIC | (method.isStatic() ? Modifier.STATIC : 0), method.getReturnType(), NameMangler.inlineAccessMethodForMethod(method.getName(), method.getDeclaringType(), aspectType), paramTypes, method.getExceptions()); } public static ResolvedMember inlineAccessMethodForFieldGet(UnresolvedType aspectType, Member field) { String sig; if (field.isStatic()) { sig = "()" + field.getReturnType().getSignature(); } else { sig = "(" + field.getDeclaringType().getSignature() + ")" + field.getReturnType().getSignature(); } return new ResolvedMemberImpl(Member.METHOD, aspectType, PUBLIC_STATIC, //Modifier.PUBLIC | (field.isStatic() ? Modifier.STATIC : 0), NameMangler.inlineAccessMethodForFieldGet(field.getName(), field.getDeclaringType(), aspectType), sig); } public static ResolvedMember inlineAccessMethodForFieldSet(UnresolvedType aspectType, Member field) { String sig; if (field.isStatic()) { sig = "(" + field.getReturnType().getSignature() + ")V"; } else { sig = "(" + field.getDeclaringType().getSignature() + field.getReturnType().getSignature() + ")V"; } return new ResolvedMemberImpl(Member.METHOD, aspectType, PUBLIC_STATIC, //Modifier.PUBLIC | (field.isStatic() ? Modifier.STATIC : 0), NameMangler.inlineAccessMethodForFieldSet(field.getName(), field.getDeclaringType(), aspectType), sig); } // --- runtimeLibrary api stuff public static Member cflowStackPeekInstance() { return new MemberImpl( Member.METHOD, CFLOW_STACK_TYPE, 0, "peekInstance", "()Ljava/lang/Object;"); } public static Member cflowStackPushInstance() { return new MemberImpl( Member.METHOD, CFLOW_STACK_TYPE, 0, "pushInstance", "(Ljava/lang/Object;)V"); } public static Member cflowStackIsValid() { return new MemberImpl( Member.METHOD, CFLOW_STACK_TYPE, 0, "isValid", "()Z"); } public static Member cflowStackInit() { return new MemberImpl( Member.CONSTRUCTOR, CFLOW_STACK_TYPE, 0, "", "()V"); } public static Member aroundClosurePreInitializationField() { return new MemberImpl( Member.FIELD, AROUND_CLOSURE_TYPE, 0, "preInitializationState", "[Ljava/lang/Object;"); } public static Member aroundClosurePreInitializationGetter() { return new MemberImpl( Member.METHOD, AROUND_CLOSURE_TYPE, 0, "getPreInitializationState", "()[Ljava/lang/Object;"); } public static ResolvedMember preIntroducedConstructor( UnresolvedType aspectType, UnresolvedType targetType, UnresolvedType[] paramTypes) { return new ResolvedMemberImpl( Member.METHOD, aspectType, PUBLIC_STATIC_FINAL, UnresolvedType.OBJECTARRAY, NameMangler.preIntroducedConstructor(aspectType, targetType), paramTypes); } public static ResolvedMember postIntroducedConstructor( UnresolvedType aspectType, UnresolvedType targetType, UnresolvedType[] paramTypes) { return new ResolvedMemberImpl( Member.METHOD, aspectType, PUBLIC_STATIC_FINAL, ResolvedType.VOID, NameMangler.postIntroducedConstructor(aspectType, targetType), UnresolvedType.insert(targetType, paramTypes)); } public static ResolvedMember itdAtDeclareParentsField(ResolvedType targetType, UnresolvedType itdType, UnresolvedType aspectType) { return new ResolvedMemberImpl( Member.FIELD, targetType, Modifier.PRIVATE, itdType, NameMangler.itdAtDeclareParentsField(aspectType, itdType), null); } public static ResolvedMember interConstructor(ResolvedType targetType, ResolvedMember constructor, UnresolvedType aspectType) { // // ResolvedType targetType, // UnresolvedType[] argTypes, // int modifiers) // { ResolvedMember ret = new ResolvedMemberImpl( Member.CONSTRUCTOR, targetType, Modifier.PUBLIC, ResolvedType.VOID, "", constructor.getParameterTypes(), constructor.getExceptions()); //System.out.println("ret: " + ret + " mods: " + Modifier.toString(modifiers)); if (Modifier.isPublic(constructor.getModifiers())) return ret; while (true) { ret = addCookieTo(ret, aspectType); if (targetType.lookupMemberNoSupers(ret) == null) return ret; } } public static ResolvedMember interFieldInitializer(ResolvedMember field, UnresolvedType aspectType) { return new ResolvedMemberImpl(Member.METHOD, aspectType, PUBLIC_STATIC, NameMangler.interFieldInitializer(aspectType, field.getDeclaringType(), field.getName()), field.isStatic() ? "()V" : "(" + field.getDeclaringType().getSignature() + ")V" ); } /** * Makes public and non-final */ private static int makePublicNonFinal(int modifiers) { return (modifiers & ~VISIBILITY & ~Modifier.FINAL) | Modifier.PUBLIC; } /** * This static method goes on the aspect that declares the inter-type field */ public static ResolvedMember interFieldSetDispatcher(ResolvedMember field, UnresolvedType aspectType) { ResolvedMember rm = new ResolvedMemberImpl(Member.METHOD, aspectType, PUBLIC_STATIC, ResolvedType.VOID, NameMangler.interFieldSetDispatcher(aspectType, field.getDeclaringType(), field.getName()), field.isStatic() ? new UnresolvedType[] {field.getReturnType()} : new UnresolvedType[] {field.getDeclaringType(), field.getReturnType()} ); rm.setTypeVariables(field.getTypeVariables()); return rm; } /** * This static method goes on the aspect that declares the inter-type field */ public static ResolvedMember interFieldGetDispatcher(ResolvedMember field, UnresolvedType aspectType) { ResolvedMember rm = new ResolvedMemberImpl(Member.METHOD, aspectType, PUBLIC_STATIC, field.getReturnType(), NameMangler.interFieldGetDispatcher(aspectType, field.getDeclaringType(), field.getName()), field.isStatic() ? UnresolvedType.NONE : new UnresolvedType[] {field.getDeclaringType()}, UnresolvedType.NONE ); rm.setTypeVariables(field.getTypeVariables()); return rm; } // private static int makeFieldModifiers(int declaredModifiers) { // int ret = Modifier.PUBLIC; // if (Modifier.isTransient(declaredModifiers)) ret |= Modifier.TRANSIENT; // if (Modifier.isVolatile(declaredModifiers)) ret |= Modifier.VOLATILE; // return ret; // } /** * This field goes on the class the field is declared onto */ public static ResolvedMember interFieldClassField(ResolvedMember field, UnresolvedType aspectType) { return new ResolvedMemberImpl(Member.FIELD, field.getDeclaringType(), makePublicNonFinal(field.getModifiers()), field.getReturnType(), NameMangler.interFieldClassField(field.getModifiers(), aspectType, field.getDeclaringType(), field.getName()), UnresolvedType.NONE, UnresolvedType.NONE ); } /** * This field goes on top-most implementers of the interface the field * is declared onto */ public static ResolvedMember interFieldInterfaceField(ResolvedMember field, UnresolvedType onClass, UnresolvedType aspectType) { return new ResolvedMemberImpl(Member.FIELD, onClass, makePublicNonFinal(field.getModifiers()), field.getReturnType(), NameMangler.interFieldInterfaceField(aspectType, field.getDeclaringType(), field.getName()), UnresolvedType.NONE, UnresolvedType.NONE ); } /** * This instance method goes on the interface the field is declared onto * as well as its top-most implementors */ public static ResolvedMember interFieldInterfaceSetter(ResolvedMember field, ResolvedType onType, UnresolvedType aspectType) { int modifiers = Modifier.PUBLIC; if (onType.isInterface()) modifiers |= Modifier.ABSTRACT; ResolvedMember rm = new ResolvedMemberImpl(Member.METHOD, onType, modifiers, ResolvedType.VOID, NameMangler.interFieldInterfaceSetter(aspectType, field.getDeclaringType(), field.getName()), new UnresolvedType[] {field.getReturnType()}, UnresolvedType.NONE ); rm.setTypeVariables(field.getTypeVariables()); return rm; } /** * This instance method goes on the interface the field is declared onto * as well as its top-most implementors */ public static ResolvedMember interFieldInterfaceGetter(ResolvedMember field, ResolvedType onType, UnresolvedType aspectType) { int modifiers = Modifier.PUBLIC; if (onType.isInterface()) modifiers |= Modifier.ABSTRACT; ResolvedMember rm = new ResolvedMemberImpl(Member.METHOD, onType, modifiers, field.getReturnType(), NameMangler.interFieldInterfaceGetter(aspectType, field.getDeclaringType(), field.getName()), UnresolvedType.NONE, UnresolvedType.NONE ); rm.setTypeVariables(field.getTypeVariables()); return rm; } /** * This method goes on the target type of the inter-type method. (and possibly the topmost-implementors, * if the target type is an interface). The implementation will call the interMethodDispatch method on the * aspect. */ public static ResolvedMember interMethod(ResolvedMember meth, UnresolvedType aspectType, boolean onInterface) { if (Modifier.isPublic(meth.getModifiers()) && !onInterface) return meth; int modifiers = makePublicNonFinal(meth.getModifiers()); if (onInterface) modifiers |= Modifier.ABSTRACT; ResolvedMemberImpl rmi = new ResolvedMemberImpl(Member.METHOD, meth.getDeclaringType(), modifiers, meth.getReturnType(), NameMangler.interMethod(meth.getModifiers(), aspectType, meth.getDeclaringType(), meth.getName()), meth.getParameterTypes(), meth.getExceptions()); rmi.setTypeVariables(meth.getTypeVariables()); return rmi; } /** * Sometimes the intertyped method requires a bridge method alongside it. For example if the method 'N SomeI.m()' * is put onto an interface 'interface I' and then a concrete implementation is 'class C implements I' * then the ITD on the interface will be 'Number m()', whereas the ITD on the 'topmostimplementor' will be * 'Float m()'. A bridge method needs to be created in the topmostimplementor 'Number m()' that delegates to 'Float m()' */ public static ResolvedMember bridgerToInterMethod(ResolvedMember meth, UnresolvedType aspectType) { int modifiers = makePublicNonFinal(meth.getModifiers()); ResolvedMemberImpl rmi = new ResolvedMemberImpl(Member.METHOD, aspectType, modifiers, meth.getReturnType(), NameMangler.interMethod(meth.getModifiers(), aspectType, meth.getDeclaringType(), meth.getName()), meth.getParameterTypes(), meth.getExceptions()); rmi.setTypeVariables(meth.getTypeVariables()); return rmi; } /** * This static method goes on the declaring aspect of the inter-type method. The implementation * calls the interMethodBody() method on the aspect. */ public static ResolvedMember interMethodDispatcher(ResolvedMember meth, UnresolvedType aspectType) { UnresolvedType[] paramTypes = meth.getParameterTypes(); if (!meth.isStatic()) { paramTypes = UnresolvedType.insert(meth.getDeclaringType(), paramTypes); } ResolvedMemberImpl rmi = new ResolvedMemberImpl(Member.METHOD, aspectType, PUBLIC_STATIC, meth.getReturnType(), NameMangler.interMethodDispatcher(aspectType, meth.getDeclaringType(), meth.getName()), paramTypes, meth.getExceptions()); rmi.setTypeVariables(meth.getTypeVariables()); return rmi; } /** * This method goes on the declaring aspect of the inter-type method. * It contains the real body of the ITD method. */ public static ResolvedMember interMethodBody(ResolvedMember meth, UnresolvedType aspectType) { UnresolvedType[] paramTypes = meth.getParameterTypes(); if (!meth.isStatic()) { paramTypes = UnresolvedType.insert(meth.getDeclaringType(), paramTypes); } int modifiers = PUBLIC_STATIC; if (Modifier.isStrict(meth.getModifiers())) { modifiers |= Modifier.STRICT; } ResolvedMemberImpl rmi = new ResolvedMemberImpl(Member.METHOD, aspectType, modifiers, meth.getReturnType(), NameMangler.interMethodBody(aspectType, meth.getDeclaringType(), meth.getName()), paramTypes, meth.getExceptions()); rmi.setTypeVariables(meth.getTypeVariables()); return rmi; } private static ResolvedMember addCookieTo(ResolvedMember ret, UnresolvedType aspectType) { UnresolvedType[] params = ret.getParameterTypes(); UnresolvedType[] freshParams = UnresolvedType.add(params, aspectType); return new ResolvedMemberImpl( ret.getKind(), ret.getDeclaringType(), ret.getModifiers(), ret.getReturnType(), ret.getName(), freshParams, ret.getExceptions()); } public static ResolvedMember toObjectConversionMethod(UnresolvedType fromType) { if (fromType.isPrimitiveType()) { String name = fromType.toString() + "Object"; return new ResolvedMemberImpl( Member.METHOD, CONVERSIONS_TYPE, PUBLIC_STATIC, UnresolvedType.OBJECT, name, new UnresolvedType[] { fromType }, UnresolvedType.NONE); } else { return null; } } public static Member interfaceConstructor(ResolvedType resolvedTypeX) { // AMC next two lines should not be needed when sig for generic type is changed ResolvedType declaringType = resolvedTypeX; if (declaringType.isRawType()) declaringType = declaringType.getGenericType(); return new ResolvedMemberImpl( Member.CONSTRUCTOR, declaringType, Modifier.PUBLIC, "", "()V"); } //-- common types we use. Note: Java 5 dependand types are refered to as String public final static UnresolvedType ASPECT_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.Aspect"); public final static UnresolvedType BEFORE_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.Before"); public final static UnresolvedType AROUND_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.Around"); public final static UnresolvedType AFTERRETURNING_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.AfterReturning"); public final static UnresolvedType AFTERTHROWING_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.AfterThrowing"); public final static UnresolvedType AFTER_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.After"); public final static UnresolvedType POINTCUT_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.Pointcut"); public final static UnresolvedType DECLAREERROR_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.DeclareError"); public final static UnresolvedType DECLAREWARNING_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.DeclareWarning"); public final static UnresolvedType DECLAREPRECEDENCE_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.DeclarePrecedence"); public final static UnresolvedType DECLAREIMPLEMENTS_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.DeclareImplements"); public final static UnresolvedType DECLAREPARENTS_ANNOTATION = UnresolvedType.forName("org.aspectj.lang.annotation.DeclareParents"); public final static UnresolvedType TYPEX_JOINPOINT = UnresolvedType.forName(JoinPoint.class.getName().replace('/','.')); public final static UnresolvedType TYPEX_PROCEEDINGJOINPOINT = UnresolvedType.forName(ProceedingJoinPoint.class.getName().replace('/','.')); public final static UnresolvedType TYPEX_STATICJOINPOINT = UnresolvedType.forName(JoinPoint.StaticPart.class.getName().replace('/','.')); public final static UnresolvedType TYPEX_ENCLOSINGSTATICJOINPOINT = UnresolvedType.forName(JoinPoint.EnclosingStaticPart.class.getName().replace('/','.')); }