* Alexandre Vasseur @AspectJ ITDs
* ******************************************************************/
-
package org.aspectj.weaver;
import java.lang.reflect.Modifier;
public abstract class ResolvedType extends UnresolvedType implements AnnotatedElement {
- public static final ResolvedType[] EMPTY_RESOLVED_TYPE_ARRAY = new ResolvedType[0];
+ public static final ResolvedType[] EMPTY_RESOLVED_TYPE_ARRAY = new ResolvedType[0];
public static final String PARAMETERIZED_TYPE_IDENTIFIER = "P";
-
// Set during a type pattern match call - this currently used to hold the annotations
// that may be attached to a type when it used as a parameter
public ResolvedType[] temporaryAnnotationTypes;
private ResolvedType[] resolvedTypeParams;
private String binaryPath;
-
- protected World world;
-
- protected ResolvedType(String signature, World world) {
- super(signature);
- this.world = world;
- }
-
- protected ResolvedType(String signature, String signatureErasure, World world) {
- super(signature,signatureErasure);
- this.world = world;
- }
-
- // ---- things that don't require a world
-
- /**
- * Returns an iterator through ResolvedType objects representing all the direct
- * supertypes of this type. That is, through the superclass, if any, and
- * all declared interfaces.
- */
- public final Iterator getDirectSupertypes() {
- Iterator ifacesIterator = Iterators.array(getDeclaredInterfaces());
- ResolvedType superclass = getSuperclass();
- if (superclass == null) {
- return ifacesIterator;
- } else {
- return Iterators.snoc(ifacesIterator, superclass);
- }
- }
-
- public abstract ResolvedMember[] getDeclaredFields();
- public abstract ResolvedMember[] getDeclaredMethods();
- public abstract ResolvedType[] getDeclaredInterfaces();
- public abstract ResolvedMember[] getDeclaredPointcuts();
- /**
- * Returns a ResolvedType object representing the superclass of this type, or null.
- * If this represents a java.lang.Object, a primitive type, or void, this
- * method returns null.
- */
- public abstract ResolvedType getSuperclass();
-
- /**
- * Returns the modifiers for this type.
- * <p/>
- * See {@link Class#getModifiers()} for a description
- * of the weirdness of this methods on primitives and arrays.
- *
- * @param world the {@link World} in which the lookup is made.
- * @return an int representing the modifiers for this type
- * @see java.lang.reflect.Modifier
- */
- public abstract int getModifiers();
-
- // return true if this resolved type couldn't be found (but we know it's name maybe)
- public boolean isMissing() {
- return false;
- }
-
- // FIXME asc I wonder if in some circumstances MissingWithKnownSignature should not be considered
- // 'really' missing as some code can continue based solely on the signature
- public static boolean isMissing (UnresolvedType unresolved) {
- if (unresolved instanceof ResolvedType) {
- ResolvedType resolved = (ResolvedType)unresolved;
- return resolved.isMissing();
- }
- else return (unresolved == MISSING);
- }
-
- public ResolvedType[] getAnnotationTypes() {
- return EMPTY_RESOLVED_TYPE_ARRAY;
- }
-
- public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
- return null;
- }
-
- public final UnresolvedType getSuperclass(World world) {
- return getSuperclass();
- }
-
-
- // This set contains pairs of types whose signatures are concatenated
- // together, this means with a fast lookup we can tell if two types
- // are equivalent.
- protected static Set validBoxing = new HashSet();
-
- static {
- validBoxing.add("Ljava/lang/Byte;B");
- validBoxing.add("Ljava/lang/Character;C");
- validBoxing.add("Ljava/lang/Double;D");
- validBoxing.add("Ljava/lang/Float;F");
- validBoxing.add("Ljava/lang/Integer;I");
- validBoxing.add("Ljava/lang/Long;J");
- validBoxing.add("Ljava/lang/Short;S");
- validBoxing.add("Ljava/lang/Boolean;Z");
- validBoxing.add("BLjava/lang/Byte;");
- validBoxing.add("CLjava/lang/Character;");
- validBoxing.add("DLjava/lang/Double;");
- validBoxing.add("FLjava/lang/Float;");
- validBoxing.add("ILjava/lang/Integer;");
- validBoxing.add("JLjava/lang/Long;");
- validBoxing.add("SLjava/lang/Short;");
- validBoxing.add("ZLjava/lang/Boolean;");
- }
-
-
-
- // utilities
- public ResolvedType getResolvedComponentType() {
- return null;
- }
+
+ protected World world;
+
+ protected ResolvedType(String signature, World world) {
+ super(signature);
+ this.world = world;
+ }
+
+ protected ResolvedType(String signature, String signatureErasure, World world) {
+ super(signature, signatureErasure);
+ this.world = world;
+ }
+
+ // ---- things that don't require a world
+
+ /**
+ * Returns an iterator through ResolvedType objects representing all the direct supertypes of this type. That is, through the
+ * superclass, if any, and all declared interfaces.
+ */
+ public final Iterator getDirectSupertypes() {
+ Iterator ifacesIterator = Iterators.array(getDeclaredInterfaces());
+ ResolvedType superclass = getSuperclass();
+ if (superclass == null) {
+ return ifacesIterator;
+ } else {
+ return Iterators.snoc(ifacesIterator, superclass);
+ }
+ }
+
+ public abstract ResolvedMember[] getDeclaredFields();
+
+ public abstract ResolvedMember[] getDeclaredMethods();
+
+ public abstract ResolvedType[] getDeclaredInterfaces();
+
+ public abstract ResolvedMember[] getDeclaredPointcuts();
+
+ /**
+ * Returns a ResolvedType object representing the superclass of this type, or null. If this represents a java.lang.Object, a
+ * primitive type, or void, this method returns null.
+ */
+ public abstract ResolvedType getSuperclass();
+
+ /**
+ * Returns the modifiers for this type. <p/> See {@link Class#getModifiers()} for a description of the weirdness of this methods
+ * on primitives and arrays.
+ *
+ * @param world the {@link World} in which the lookup is made.
+ * @return an int representing the modifiers for this type
+ * @see java.lang.reflect.Modifier
+ */
+ public abstract int getModifiers();
+
+ // return true if this resolved type couldn't be found (but we know it's name maybe)
+ public boolean isMissing() {
+ return false;
+ }
+
+ // FIXME asc I wonder if in some circumstances MissingWithKnownSignature should not be considered
+ // 'really' missing as some code can continue based solely on the signature
+ public static boolean isMissing(UnresolvedType unresolved) {
+ if (unresolved instanceof ResolvedType) {
+ ResolvedType resolved = (ResolvedType) unresolved;
+ return resolved.isMissing();
+ } else
+ return (unresolved == MISSING);
+ }
+
+ public ResolvedType[] getAnnotationTypes() {
+ return EMPTY_RESOLVED_TYPE_ARRAY;
+ }
+
+ public AnnotationX getAnnotationOfType(UnresolvedType ofType) {
+ return null;
+ }
+
+ public final UnresolvedType getSuperclass(World world) {
+ return getSuperclass();
+ }
+
+ // This set contains pairs of types whose signatures are concatenated
+ // together, this means with a fast lookup we can tell if two types
+ // are equivalent.
+ protected static Set validBoxing = new HashSet();
+
+ static {
+ validBoxing.add("Ljava/lang/Byte;B");
+ validBoxing.add("Ljava/lang/Character;C");
+ validBoxing.add("Ljava/lang/Double;D");
+ validBoxing.add("Ljava/lang/Float;F");
+ validBoxing.add("Ljava/lang/Integer;I");
+ validBoxing.add("Ljava/lang/Long;J");
+ validBoxing.add("Ljava/lang/Short;S");
+ validBoxing.add("Ljava/lang/Boolean;Z");
+ validBoxing.add("BLjava/lang/Byte;");
+ validBoxing.add("CLjava/lang/Character;");
+ validBoxing.add("DLjava/lang/Double;");
+ validBoxing.add("FLjava/lang/Float;");
+ validBoxing.add("ILjava/lang/Integer;");
+ validBoxing.add("JLjava/lang/Long;");
+ validBoxing.add("SLjava/lang/Short;");
+ validBoxing.add("ZLjava/lang/Boolean;");
+ }
+
+ // utilities
+ public ResolvedType getResolvedComponentType() {
+ return null;
+ }
public World getWorld() {
return world;
}
- // ---- things from object
-
- public final boolean equals(Object other) {
- if (other instanceof ResolvedType) {
- return this == other;
- } else {
- return super.equals(other);
- }
- }
-
- // ---- difficult things
-
- /**
- * returns an iterator through all of the fields of this type, in order
- * for checking from JVM spec 2ed 5.4.3.2. This means that the order is
- * <p/>
- * <ul><li> fields from current class </li>
- * <li> recur into direct superinterfaces </li>
- * <li> recur into superclass </li>
- * </ul>
- * <p/>
- * We keep a hashSet of interfaces that we've visited so we don't spiral
- * out into 2^n land.
- */
- public Iterator getFields() {
- final Iterators.Filter dupFilter = Iterators.dupFilter();
- Iterators.Getter typeGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- return
- dupFilter.filter(
- ((ResolvedType)o).getDirectSupertypes());
- }
- };
- Iterators.Getter fieldGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- return Iterators.array(((ResolvedType)o).getDeclaredFields());
- }
- };
- return
- Iterators.mapOver(
- Iterators.recur(this, typeGetter),
- fieldGetter);
- }
-
- /**
- * returns an iterator through all of the methods of this type, in order
- * for checking from JVM spec 2ed 5.4.3.3. This means that the order is
- * <p/>
- * <ul><li> methods from current class </li>
- * <li> recur into superclass, all the way up, not touching interfaces </li>
- * <li> recur into all superinterfaces, in some unspecified order </li>
- * </ul>
- * <p/>
- * We keep a hashSet of interfaces that we've visited so we don't spiral
- * out into 2^n land.
- * NOTE: Take a look at the javadoc on getMethodsWithoutIterator() to see if
- * you are sensitive to a quirk in getMethods()
- */
- public Iterator getMethods() {
- final Iterators.Filter dupFilter = Iterators.dupFilter();
- Iterators.Getter ifaceGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- return
- dupFilter.filter(
- Iterators.array(((ResolvedType)o).getDeclaredInterfaces())
- );
- }
- };
- Iterators.Getter methodGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- return Iterators.array(((ResolvedType)o).getDeclaredMethods());
- }
- };
- return
- Iterators.mapOver(
- Iterators.append(
- new Iterator() {
- ResolvedType curr = ResolvedType.this;
- public boolean hasNext() {
- return curr != null;
- }
- public Object next() {
- ResolvedType ret = curr;
- curr = curr.getSuperclass();
- return ret;
- }
- public void remove() {
- throw new UnsupportedOperationException();
- }
- },
- Iterators.recur(this, ifaceGetter)),
- methodGetter);
- }
-
- /**
- * Return a list of methods, first those declared on this class, then those declared on the superclass (recurse) and then those declared
- * on the superinterfaces. The getMethods() call above doesn't quite work the same as it will (through the iterator) return methods
- * declared on *this* class twice, once at the start and once at the end - I couldn't debug that problem, so created this alternative.
- */
- public List getMethodsWithoutIterator(boolean includeITDs, boolean allowMissing) {
- List methods = new ArrayList();
- Set knowninterfaces = new HashSet();
- addAndRecurse(knowninterfaces,methods,this,includeITDs,allowMissing);
- return methods;
- }
-
- private void addAndRecurse(Set knowninterfaces,List collector, ResolvedType rtx, boolean includeITDs, boolean allowMissing) {
- collector.addAll(Arrays.asList(rtx.getDeclaredMethods())); // Add the methods declared on this type
- // now add all the inter-typed members too
- if (includeITDs && rtx.interTypeMungers != null) {
- for (Iterator i = interTypeMungers.iterator(); i.hasNext();) {
- ConcreteTypeMunger tm = (ConcreteTypeMunger) i.next();
+ // ---- things from object
+
+ public final boolean equals(Object other) {
+ if (other instanceof ResolvedType) {
+ return this == other;
+ } else {
+ return super.equals(other);
+ }
+ }
+
+ // ---- difficult things
+
+ /**
+ * returns an iterator through all of the fields of this type, in order for checking from JVM spec 2ed 5.4.3.2. This means that
+ * the order is <p/>
+ * <ul>
+ * <li>fields from current class</li>
+ * <li>recur into direct superinterfaces</li>
+ * <li>recur into superclass</li>
+ * </ul>
+ * <p/> We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land.
+ */
+ public Iterator getFields() {
+ final Iterators.Filter dupFilter = Iterators.dupFilter();
+ Iterators.Getter typeGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ }
+ };
+ Iterators.Getter fieldGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ return Iterators.array(((ResolvedType) o).getDeclaredFields());
+ }
+ };
+ return Iterators.mapOver(Iterators.recur(this, typeGetter), fieldGetter);
+ }
+
+ /**
+ * returns an iterator through all of the methods of this type, in order for checking from JVM spec 2ed 5.4.3.3. This means that
+ * the order is <p/>
+ * <ul>
+ * <li>methods from current class</li>
+ * <li>recur into superclass, all the way up, not touching interfaces</li>
+ * <li>recur into all superinterfaces, in some unspecified order</li>
+ * </ul>
+ * <p/> We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land. NOTE: Take a look at the
+ * javadoc on getMethodsWithoutIterator() to see if you are sensitive to a quirk in getMethods()
+ */
+ public Iterator getMethods() {
+ final Iterators.Filter dupFilter = Iterators.dupFilter();
+ Iterators.Getter ifaceGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ return dupFilter.filter(Iterators.array(((ResolvedType) o).getDeclaredInterfaces()));
+ }
+ };
+ Iterators.Getter methodGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ return Iterators.array(((ResolvedType) o).getDeclaredMethods());
+ }
+ };
+ return Iterators.mapOver(Iterators.append(new Iterator() {
+ ResolvedType curr = ResolvedType.this;
+
+ public boolean hasNext() {
+ return curr != null;
+ }
+
+ public Object next() {
+ ResolvedType ret = curr;
+ curr = curr.getSuperclass();
+ return ret;
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ }, Iterators.recur(this, ifaceGetter)), methodGetter);
+ }
+
+ /**
+ * Return a list of methods, first those declared on this class, then those declared on the superclass (recurse) and then those
+ * declared on the superinterfaces. The getMethods() call above doesn't quite work the same as it will (through the iterator)
+ * return methods declared on *this* class twice, once at the start and once at the end - I couldn't debug that problem, so
+ * created this alternative.
+ */
+ public List getMethodsWithoutIterator(boolean includeITDs, boolean allowMissing) {
+ List methods = new ArrayList();
+ Set knowninterfaces = new HashSet();
+ addAndRecurse(knowninterfaces, methods, this, includeITDs, allowMissing);
+ return methods;
+ }
+
+ private void addAndRecurse(Set knowninterfaces, List collector, ResolvedType rtx, boolean includeITDs, boolean allowMissing) {
+ collector.addAll(Arrays.asList(rtx.getDeclaredMethods())); // Add the methods declared on this type
+ // now add all the inter-typed members too
+ if (includeITDs && rtx.interTypeMungers != null) {
+ for (Iterator i = interTypeMungers.iterator(); i.hasNext();) {
+ ConcreteTypeMunger tm = (ConcreteTypeMunger) i.next();
ResolvedMember rm = tm.getSignature();
- if (rm != null) { // new parent type munger can have null signature...
+ if (rm != null) { // new parent type munger can have null signature...
collector.add(tm.getSignature());
- }
+ }
+ }
+ }
+ if (!rtx.equals(ResolvedType.OBJECT)) {
+ ResolvedType superType = rtx.getSuperclass();
+ if (superType != null && !superType.isMissing()) {
+ addAndRecurse(knowninterfaces, collector, superType, includeITDs, allowMissing); // Recurse if we aren't at the top
+ }
+ }
+ ResolvedType[] interfaces = rtx.getDeclaredInterfaces(); // Go through the interfaces on the way back down
+ for (int i = 0; i < interfaces.length; i++) {
+ ResolvedType iface = interfaces[i];
+
+ // we need to know if it is an interface from Parent kind munger
+ // as those are used for @AJ ITD and we precisely want to skip those
+ boolean shouldSkip = false;
+ for (int j = 0; j < rtx.interTypeMungers.size(); j++) {
+ ConcreteTypeMunger munger = (ConcreteTypeMunger) rtx.interTypeMungers.get(j);
+ if (munger.getMunger() != null && munger.getMunger().getKind() == ResolvedTypeMunger.Parent
+ && ((NewParentTypeMunger) munger.getMunger()).getNewParent().equals(iface) // pr171953
+ ) {
+ shouldSkip = true;
+ break;
+ }
+ }
+
+ if (!shouldSkip && !knowninterfaces.contains(iface)) { // Dont do interfaces more than once
+ knowninterfaces.add(iface);
+ if (allowMissing && iface.isMissing()) {
+ if (iface instanceof MissingResolvedTypeWithKnownSignature) {
+ ((MissingResolvedTypeWithKnownSignature) iface).raiseWarningOnMissingInterfaceWhilstFindingMethods();
+ }
+ } else {
+ addAndRecurse(knowninterfaces, collector, iface, includeITDs, allowMissing);
+ }
}
- }
- if (!rtx.equals(ResolvedType.OBJECT)) {
- ResolvedType superType = rtx.getSuperclass();
- if (superType != null && !superType.isMissing()) {
- addAndRecurse(knowninterfaces,collector,superType,includeITDs,allowMissing); // Recurse if we aren't at the top
- }
- }
- ResolvedType[] interfaces = rtx.getDeclaredInterfaces(); // Go through the interfaces on the way back down
- for (int i = 0; i < interfaces.length; i++) {
- ResolvedType iface = interfaces[i];
-
- // we need to know if it is an interface from Parent kind munger
- // as those are used for @AJ ITD and we precisely want to skip those
- boolean shouldSkip = false;
- for (int j = 0; j < rtx.interTypeMungers.size(); j++) {
- ConcreteTypeMunger munger = (ConcreteTypeMunger) rtx.interTypeMungers.get(j);
- if (munger.getMunger()!=null && munger.getMunger().getKind() == ResolvedTypeMunger.Parent
- && ((NewParentTypeMunger)munger.getMunger()).getNewParent().equals(iface) // pr171953
- ) {
- shouldSkip = true;
- break;
- }
- }
-
- if (!shouldSkip && !knowninterfaces.contains(iface)) { // Dont do interfaces more than once
- knowninterfaces.add(iface);
- if (allowMissing && iface.isMissing()) {
- if (iface instanceof MissingResolvedTypeWithKnownSignature) {
- ((MissingResolvedTypeWithKnownSignature)iface).raiseWarningOnMissingInterfaceWhilstFindingMethods();
- }
- } else {
- addAndRecurse(knowninterfaces,collector,iface,includeITDs,allowMissing);
- }
- }
- }
- }
-
- public ResolvedType[] getResolvedTypeParameters() {
- if (resolvedTypeParams == null) {
- resolvedTypeParams = world.resolve(typeParameters);
- }
- return resolvedTypeParams;
- }
-
- /**
- * described in JVM spec 2ed 5.4.3.2
- */
- public ResolvedMember lookupField(Member m) {
- return lookupMember(m, getFields());
- }
-
- /**
- * described in JVM spec 2ed 5.4.3.3.
- * Doesnt check ITDs.
- */
- public ResolvedMember lookupMethod(Member m) {
- return lookupMember(m, getMethods());
- }
-
- public ResolvedMember lookupMethodInITDs(Member m) {
- if (interTypeMungers != null) {
+ }
+ }
+
+ public ResolvedType[] getResolvedTypeParameters() {
+ if (resolvedTypeParams == null) {
+ resolvedTypeParams = world.resolve(typeParameters);
+ }
+ return resolvedTypeParams;
+ }
+
+ /**
+ * described in JVM spec 2ed 5.4.3.2
+ */
+ public ResolvedMember lookupField(Member m) {
+ return lookupMember(m, getFields());
+ }
+
+ /**
+ * described in JVM spec 2ed 5.4.3.3. Doesnt check ITDs.
+ */
+ public ResolvedMember lookupMethod(Member m) {
+ return lookupMember(m, getMethods());
+ }
+
+ public ResolvedMember lookupMethodInITDs(Member m) {
+ if (interTypeMungers != null) {
for (Iterator i = interTypeMungers.iterator(); i.hasNext();) {
ConcreteTypeMunger tm = (ConcreteTypeMunger) i.next();
if (matches(tm.getSignature(), m)) {
}
}
}
- return null;
- }
-
- /**
- * return null if not found
- */
- private ResolvedMember lookupMember(Member m, Iterator i) {
- while (i.hasNext()) {
- ResolvedMember f = (ResolvedMember) i.next();
- if (matches(f, m)) return f;
- if (f.hasBackingGenericMember() && m.getName().equals(f.getName())) { // might be worth checking the method behind the parameterized method (see pr137496)
- if (matches(f.getBackingGenericMember(),m)) return f;
- }
- }
- return null; //ResolvedMember.Missing;
- //throw new BCException("can't find " + m);
- }
-
- /**
- * return null if not found
- */
- private ResolvedMember lookupMember(Member m, ResolvedMember[] a) {
+ return null;
+ }
+
+ /**
+ * return null if not found
+ */
+ private ResolvedMember lookupMember(Member m, Iterator i) {
+ while (i.hasNext()) {
+ ResolvedMember f = (ResolvedMember) i.next();
+ if (matches(f, m))
+ return f;
+ if (f.hasBackingGenericMember() && m.getName().equals(f.getName())) { // might be worth checking the method behind the
+ // parameterized method (see pr137496)
+ if (matches(f.getBackingGenericMember(), m))
+ return f;
+ }
+ }
+ return null; // ResolvedMember.Missing;
+ // throw new BCException("can't find " + m);
+ }
+
+ /**
+ * return null if not found
+ */
+ private ResolvedMember lookupMember(Member m, ResolvedMember[] a) {
for (int i = 0; i < a.length; i++) {
ResolvedMember f = a[i];
- if (matches(f, m)) return f;
+ if (matches(f, m))
+ return f;
}
return null;
- }
-
-
- /**
- * Looks for the first member in the hierarchy matching aMember. This method
- * differs from lookupMember(Member) in that it takes into account parameters
- * which are type variables - which clearly an unresolved Member cannot do since
- * it does not know anything about type variables.
- */
- public ResolvedMember lookupResolvedMember(ResolvedMember aMember,boolean allowMissing) {
- Iterator toSearch = null;
- ResolvedMember found = null;
- if ((aMember.getKind() == Member.METHOD) || (aMember.getKind() == Member.CONSTRUCTOR)) {
- toSearch = getMethodsWithoutIterator(true,allowMissing).iterator();
- } else {
- if (aMember.getKind() != Member.FIELD)
- throw new IllegalStateException("I didn't know you would look for members of kind " + aMember.getKind());
- toSearch = getFields();
- }
- while(toSearch.hasNext()) {
- ResolvedMemberImpl candidate = (ResolvedMemberImpl) toSearch.next();
+ }
+
+ /**
+ * Looks for the first member in the hierarchy matching aMember. This method differs from lookupMember(Member) in that it takes
+ * into account parameters which are type variables - which clearly an unresolved Member cannot do since it does not know
+ * anything about type variables.
+ */
+ public ResolvedMember lookupResolvedMember(ResolvedMember aMember, boolean allowMissing) {
+ Iterator toSearch = null;
+ ResolvedMember found = null;
+ if ((aMember.getKind() == Member.METHOD) || (aMember.getKind() == Member.CONSTRUCTOR)) {
+ toSearch = getMethodsWithoutIterator(true, allowMissing).iterator();
+ } else {
+ if (aMember.getKind() != Member.FIELD)
+ throw new IllegalStateException("I didn't know you would look for members of kind " + aMember.getKind());
+ toSearch = getFields();
+ }
+ while (toSearch.hasNext()) {
+ ResolvedMemberImpl candidate = (ResolvedMemberImpl) toSearch.next();
if (candidate.matches(aMember)) {
found = candidate;
break;
- }
- }
-
- return found;
- }
-
- public static boolean matches(Member m1, Member m2) {
- if (m1 == null) return m2 == null;
- if (m2 == null) return false;
-
- // Check the names
- boolean equalNames = m1.getName().equals(m2.getName());
- if (!equalNames) return false;
-
- // Check the signatures
- boolean equalSignatures = m1.getSignature().equals(m2.getSignature());
- if (equalSignatures) return true;
-
- // If they aren't the same, we need to allow for covariance ... where one sig might be ()LCar; and
- // the subsig might be ()LFastCar; - where FastCar is a subclass of Car
- boolean equalCovariantSignatures = m1.getParameterSignature().equals(m2.getParameterSignature());
- if (equalCovariantSignatures) return true;
-
- return false;
- }
-
- public static boolean conflictingSignature(Member m1, Member m2) {
- if (m1 == null || m2 == null) return false;
-
- if (!m1.getName().equals(m2.getName())) {
- return false;
- }
- if (m1.getKind() != m2.getKind()) {
- return false;
- }
-
- if (m1.getKind() == Member.FIELD) {
- return m1.getDeclaringType().equals(m2.getDeclaringType());
- } else if (m1.getKind() == Member.POINTCUT) {
- return true;
- }
-
-
- UnresolvedType[] p1 = m1.getGenericParameterTypes();
- UnresolvedType[] p2 = m2.getGenericParameterTypes();
- if (p1==null) p1 = m1.getParameterTypes();
- if (p2==null) p2 = m2.getParameterTypes();
- int n = p1.length;
- if (n != p2.length) return false;
-
- for (int i=0; i < n; i++) {
- if (!p1[i].equals(p2[i])) return false;
- }
- return true;
- }
-
-
- /**
- * returns an iterator through all of the pointcuts of this type, in order
- * for checking from JVM spec 2ed 5.4.3.2 (as for fields). This means that the order is
- * <p/>
- * <ul><li> pointcuts from current class </li>
- * <li> recur into direct superinterfaces </li>
- * <li> recur into superclass </li>
- * </ul>
- * <p/>
- * We keep a hashSet of interfaces that we've visited so we don't spiral
- * out into 2^n land.
- */
- public Iterator getPointcuts() {
- final Iterators.Filter dupFilter = Iterators.dupFilter();
- // same order as fields
- Iterators.Getter typeGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- return
- dupFilter.filter(
- ((ResolvedType)o).getDirectSupertypes());
- }
- };
- Iterators.Getter pointcutGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- //System.err.println("getting for " + o);
- return Iterators.array(((ResolvedType)o).getDeclaredPointcuts());
- }
- };
- return
- Iterators.mapOver(
- Iterators.recur(this, typeGetter),
- pointcutGetter);
- }
-
- public ResolvedPointcutDefinition findPointcut(String name) {
- //System.err.println("looking for pointcuts " + this);
- for (Iterator i = getPointcuts(); i.hasNext(); ) {
- ResolvedPointcutDefinition f = (ResolvedPointcutDefinition) i.next();
- //System.err.println(f);
- if (name.equals(f.getName())) {
- return f;
- }
- }
- // pr120521
- if (!getOutermostType().equals(this)) {
- ResolvedType outerType = getOutermostType().resolve(world);
- ResolvedPointcutDefinition rpd = outerType.findPointcut(name);
- return rpd;
- }
- return null; // should we throw an exception here?
- }
-
-
- // all about collecting CrosscuttingMembers
-
- //??? collecting data-structure, shouldn't really be a field
- public CrosscuttingMembers crosscuttingMembers;
+ }
+ }
+
+ return found;
+ }
+
+ public static boolean matches(Member m1, Member m2) {
+ if (m1 == null)
+ return m2 == null;
+ if (m2 == null)
+ return false;
+
+ // Check the names
+ boolean equalNames = m1.getName().equals(m2.getName());
+ if (!equalNames)
+ return false;
+
+ // Check the signatures
+ boolean equalSignatures = m1.getSignature().equals(m2.getSignature());
+ if (equalSignatures)
+ return true;
+
+ // If they aren't the same, we need to allow for covariance ... where one sig might be ()LCar; and
+ // the subsig might be ()LFastCar; - where FastCar is a subclass of Car
+ boolean equalCovariantSignatures = m1.getParameterSignature().equals(m2.getParameterSignature());
+ if (equalCovariantSignatures)
+ return true;
+
+ return false;
+ }
+
+ public static boolean conflictingSignature(Member m1, Member m2) {
+ if (m1 == null || m2 == null)
+ return false;
+
+ if (!m1.getName().equals(m2.getName())) {
+ return false;
+ }
+ if (m1.getKind() != m2.getKind()) {
+ return false;
+ }
+
+ if (m1.getKind() == Member.FIELD) {
+ return m1.getDeclaringType().equals(m2.getDeclaringType());
+ } else if (m1.getKind() == Member.POINTCUT) {
+ return true;
+ }
+
+ UnresolvedType[] p1 = m1.getGenericParameterTypes();
+ UnresolvedType[] p2 = m2.getGenericParameterTypes();
+ if (p1 == null)
+ p1 = m1.getParameterTypes();
+ if (p2 == null)
+ p2 = m2.getParameterTypes();
+ int n = p1.length;
+ if (n != p2.length)
+ return false;
+
+ for (int i = 0; i < n; i++) {
+ if (!p1[i].equals(p2[i]))
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * returns an iterator through all of the pointcuts of this type, in order for checking from JVM spec 2ed 5.4.3.2 (as for
+ * fields). This means that the order is <p/>
+ * <ul>
+ * <li>pointcuts from current class</li>
+ * <li>recur into direct superinterfaces</li>
+ * <li>recur into superclass</li>
+ * </ul>
+ * <p/> We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land.
+ */
+ public Iterator getPointcuts() {
+ final Iterators.Filter dupFilter = Iterators.dupFilter();
+ // same order as fields
+ Iterators.Getter typeGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ }
+ };
+ Iterators.Getter pointcutGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ // System.err.println("getting for " + o);
+ return Iterators.array(((ResolvedType) o).getDeclaredPointcuts());
+ }
+ };
+ return Iterators.mapOver(Iterators.recur(this, typeGetter), pointcutGetter);
+ }
+
+ public ResolvedPointcutDefinition findPointcut(String name) {
+ // System.err.println("looking for pointcuts " + this);
+ for (Iterator i = getPointcuts(); i.hasNext();) {
+ ResolvedPointcutDefinition f = (ResolvedPointcutDefinition) i.next();
+ // System.err.println(f);
+ if (name.equals(f.getName())) {
+ return f;
+ }
+ }
+ // pr120521
+ if (!getOutermostType().equals(this)) {
+ ResolvedType outerType = getOutermostType().resolve(world);
+ ResolvedPointcutDefinition rpd = outerType.findPointcut(name);
+ return rpd;
+ }
+ return null; // should we throw an exception here?
+ }
+
+ // all about collecting CrosscuttingMembers
+
+ // ??? collecting data-structure, shouldn't really be a field
+ public CrosscuttingMembers crosscuttingMembers;
public CrosscuttingMembers collectCrosscuttingMembers(boolean shouldConcretizeIfNeeded) {
- crosscuttingMembers = new CrosscuttingMembers(this,shouldConcretizeIfNeeded);
+ crosscuttingMembers = new CrosscuttingMembers(this, shouldConcretizeIfNeeded);
crosscuttingMembers.setPerClause(getPerClause());
crosscuttingMembers.addShadowMungers(collectShadowMungers());
// GENERICITDFIX
-// crosscuttingMembers.addTypeMungers(collectTypeMungers());
- crosscuttingMembers.addTypeMungers(getTypeMungers());
- //FIXME AV - skip but needed ?? or ?? crosscuttingMembers.addLateTypeMungers(getLateTypeMungers());
+ // crosscuttingMembers.addTypeMungers(collectTypeMungers());
+ crosscuttingMembers.addTypeMungers(getTypeMungers());
+ // FIXME AV - skip but needed ?? or ?? crosscuttingMembers.addLateTypeMungers(getLateTypeMungers());
crosscuttingMembers.addDeclares(collectDeclares(!this.doesNotExposeShadowMungers()));
crosscuttingMembers.addPrivilegedAccesses(getPrivilegedAccesses());
-
-
- //System.err.println("collected cc members: " + this + ", " + collectDeclares());
+
+ // System.err.println("collected cc members: " + this + ", " + collectDeclares());
return crosscuttingMembers;
}
-
+
public final Collection collectTypeMungers() {
- if (! this.isAspect() ) return Collections.EMPTY_LIST;
-
+ if (!this.isAspect())
+ return Collections.EMPTY_LIST;
+
ArrayList ret = new ArrayList();
- //if (this.isAbstract()) {
-// for (Iterator i = getDeclares().iterator(); i.hasNext();) {
-// Declare dec = (Declare) i.next();
-// if (!dec.isAdviceLike()) ret.add(dec);
-// }
-//
-// if (!includeAdviceLike) return ret;
-
+ // if (this.isAbstract()) {
+ // for (Iterator i = getDeclares().iterator(); i.hasNext();) {
+ // Declare dec = (Declare) i.next();
+ // if (!dec.isAdviceLike()) ret.add(dec);
+ // }
+ //
+ // if (!includeAdviceLike) return ret;
+
if (!this.isAbstract()) {
final Iterators.Filter dupFilter = Iterators.dupFilter();
- Iterators.Getter typeGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- return
- dupFilter.filter(
- ((ResolvedType)o).getDirectSupertypes());
- }
- };
- Iterator typeIterator = Iterators.recur(this, typeGetter);
-
- while (typeIterator.hasNext()) {
- ResolvedType ty = (ResolvedType) typeIterator.next();
- for (Iterator i = ty.getTypeMungers().iterator(); i.hasNext();) {
- ConcreteTypeMunger dec = (ConcreteTypeMunger) i.next();
+ Iterators.Getter typeGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ }
+ };
+ Iterator typeIterator = Iterators.recur(this, typeGetter);
+
+ while (typeIterator.hasNext()) {
+ ResolvedType ty = (ResolvedType) typeIterator.next();
+ for (Iterator i = ty.getTypeMungers().iterator(); i.hasNext();) {
+ ConcreteTypeMunger dec = (ConcreteTypeMunger) i.next();
ret.add(dec);
}
- }
+ }
}
-
+
return ret;
- }
-
+ }
+
public final Collection collectDeclares(boolean includeAdviceLike) {
- if (! this.isAspect() ) return Collections.EMPTY_LIST;
-
+ if (!this.isAspect())
+ return Collections.EMPTY_LIST;
+
ArrayList ret = new ArrayList();
- //if (this.isAbstract()) {
-// for (Iterator i = getDeclares().iterator(); i.hasNext();) {
-// Declare dec = (Declare) i.next();
-// if (!dec.isAdviceLike()) ret.add(dec);
-// }
-//
-// if (!includeAdviceLike) return ret;
-
+ // if (this.isAbstract()) {
+ // for (Iterator i = getDeclares().iterator(); i.hasNext();) {
+ // Declare dec = (Declare) i.next();
+ // if (!dec.isAdviceLike()) ret.add(dec);
+ // }
+ //
+ // if (!includeAdviceLike) return ret;
+
if (!this.isAbstract()) {
- //ret.addAll(getDeclares());
+ // ret.addAll(getDeclares());
final Iterators.Filter dupFilter = Iterators.dupFilter();
- Iterators.Getter typeGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- return
- dupFilter.filter(
- ((ResolvedType)o).getDirectSupertypes());
- }
- };
- Iterator typeIterator = Iterators.recur(this, typeGetter);
-
- while (typeIterator.hasNext()) {
- ResolvedType ty = (ResolvedType) typeIterator.next();
- //System.out.println("super: " + ty + ", " + );
- for (Iterator i = ty.getDeclares().iterator(); i.hasNext();) {
+ Iterators.Getter typeGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ }
+ };
+ Iterator typeIterator = Iterators.recur(this, typeGetter);
+
+ while (typeIterator.hasNext()) {
+ ResolvedType ty = (ResolvedType) typeIterator.next();
+ // System.out.println("super: " + ty + ", " + );
+ for (Iterator i = ty.getDeclares().iterator(); i.hasNext();) {
Declare dec = (Declare) i.next();
if (dec.isAdviceLike()) {
- if (includeAdviceLike) ret.add(dec);
+ if (includeAdviceLike)
+ ret.add(dec);
} else {
ret.add(dec);
}
}
- }
+ }
}
-
+
return ret;
- }
-
-
-
-
- private final Collection collectShadowMungers() {
- if (! this.isAspect() || this.isAbstract() || this.doesNotExposeShadowMungers()) return Collections.EMPTY_LIST;
+ }
+
+ private final Collection collectShadowMungers() {
+ if (!this.isAspect() || this.isAbstract() || this.doesNotExposeShadowMungers())
+ return Collections.EMPTY_LIST;
ArrayList acc = new ArrayList();
- final Iterators.Filter dupFilter = Iterators.dupFilter();
- Iterators.Getter typeGetter = new Iterators.Getter() {
- public Iterator get(Object o) {
- return
- dupFilter.filter(
- ((ResolvedType)o).getDirectSupertypes());
- }
- };
- Iterator typeIterator = Iterators.recur(this, typeGetter);
-
- while (typeIterator.hasNext()) {
- ResolvedType ty = (ResolvedType) typeIterator.next();
- acc.addAll(ty.getDeclaredShadowMungers());
- }
-
- return acc;
- }
-
+ final Iterators.Filter dupFilter = Iterators.dupFilter();
+ Iterators.Getter typeGetter = new Iterators.Getter() {
+ public Iterator get(Object o) {
+ return dupFilter.filter(((ResolvedType) o).getDirectSupertypes());
+ }
+ };
+ Iterator typeIterator = Iterators.recur(this, typeGetter);
+
+ while (typeIterator.hasNext()) {
+ ResolvedType ty = (ResolvedType) typeIterator.next();
+ acc.addAll(ty.getDeclaredShadowMungers());
+ }
+
+ return acc;
+ }
+
protected boolean doesNotExposeShadowMungers() {
return false;
}
- public PerClause getPerClause() {
- return null;
- }
+ public PerClause getPerClause() {
+ return null;
+ }
protected Collection getDeclares() {
- return Collections.EMPTY_LIST;
- }
-
- protected Collection getTypeMungers() {
- return Collections.EMPTY_LIST;
- }
-
- protected Collection getPrivilegedAccesses() {
- return Collections.EMPTY_LIST;
- }
-
-
- // ---- useful things
-
- public final boolean isInterface() {
- return Modifier.isInterface(getModifiers());
- }
-
- public final boolean isAbstract() {
- return Modifier.isAbstract(getModifiers());
- }
-
- public boolean isClass() {
- return false;
- }
-
- public boolean isAspect() {
- return false;
- }
-
- public boolean isAnnotationStyleAspect() {
- return false;
- }
-
- /**
- * Note: Only overridden by Name subtype.
- */
- public boolean isEnum() {
- return false;
- }
-
- /**
- * Note: Only overridden by Name subtype.
- */
- public boolean isAnnotation() {
- return false;
- }
-
- public boolean isAnonymous() {
- return false;
- }
-
- public boolean isNested() {
- return false;
- }
-
-
- public void addAnnotation(AnnotationX annotationX) {
- throw new RuntimeException("ResolvedType.addAnnotation() should never be called");
- }
-
+ return Collections.EMPTY_LIST;
+ }
+
+ protected Collection getTypeMungers() {
+ return Collections.EMPTY_LIST;
+ }
+
+ protected Collection getPrivilegedAccesses() {
+ return Collections.EMPTY_LIST;
+ }
+
+ // ---- useful things
+
+ public final boolean isInterface() {
+ return Modifier.isInterface(getModifiers());
+ }
+
+ public final boolean isAbstract() {
+ return Modifier.isAbstract(getModifiers());
+ }
+
+ public boolean isClass() {
+ return false;
+ }
+
+ public boolean isAspect() {
+ return false;
+ }
+
+ public boolean isAnnotationStyleAspect() {
+ return false;
+ }
+
+ /**
+ * Note: Only overridden by Name subtype.
+ */
+ public boolean isEnum() {
+ return false;
+ }
+
+ /**
+ * Note: Only overridden by Name subtype.
+ */
+ public boolean isAnnotation() {
+ return false;
+ }
+
+ public boolean isAnonymous() {
+ return false;
+ }
+
+ public boolean isNested() {
+ return false;
+ }
+
+ public void addAnnotation(AnnotationX annotationX) {
+ throw new RuntimeException("ResolvedType.addAnnotation() should never be called");
+ }
+
public AnnotationX[] getAnnotations() {
throw new RuntimeException("ResolvedType.getAnnotations() should never be called");
}
-
+
/**
* Note: Only overridden by ReferenceType subtype
*/
public boolean canAnnotationTargetType() {
return false;
}
-
+
/**
* Note: Only overridden by ReferenceType subtype
- */
+ */
public AnnotationTargetKind[] getAnnotationTargetKinds() {
return null;
}
-
- /**
- * Note: Only overridden by Name subtype.
- */
- public boolean isAnnotationWithRuntimeRetention() {
- return false;
- }
-
- public boolean isSynthetic() {
- return signature.indexOf("$ajc") != -1;
- }
-
- public final boolean isFinal() {
- return Modifier.isFinal(getModifiers());
- }
-
- protected Map /*Type variable name -> UnresolvedType*/ getMemberParameterizationMap() {
- if (!isParameterizedType()) return Collections.EMPTY_MAP;
+
+ /**
+ * Note: Only overridden by Name subtype.
+ */
+ public boolean isAnnotationWithRuntimeRetention() {
+ return false;
+ }
+
+ public boolean isSynthetic() {
+ return signature.indexOf("$ajc") != -1;
+ }
+
+ public final boolean isFinal() {
+ return Modifier.isFinal(getModifiers());
+ }
+
+ protected Map /* Type variable name -> UnresolvedType */getMemberParameterizationMap() {
+ if (!isParameterizedType())
+ return Collections.EMPTY_MAP;
TypeVariable[] tvs = getGenericType().getTypeVariables();
Map parameterizationMap = new HashMap();
for (int i = 0; i < tvs.length; i++) {
parameterizationMap.put(tvs[i].getName(), typeParameters[i]);
}
- return parameterizationMap;
- }
+ return parameterizationMap;
+ }
+
+ public Collection getDeclaredAdvice() {
+ List l = new ArrayList();
+ ResolvedMember[] methods = getDeclaredMethods();
+ if (isParameterizedType())
+ methods = getGenericType().getDeclaredMethods();
+ Map typeVariableMap = getAjMemberParameterizationMap();
+ for (int i = 0, len = methods.length; i < len; i++) {
+ ShadowMunger munger = methods[i].getAssociatedShadowMunger();
+ if (munger != null) {
+ if (ajMembersNeedParameterization()) {
+ // munger.setPointcut(munger.getPointcut().parameterizeWith(typeVariableMap));
+ munger = munger.parameterizeWith(this, typeVariableMap);
+ if (munger instanceof Advice) {
+ Advice advice = (Advice) munger;
+ // update to use the parameterized signature...
+ UnresolvedType[] ptypes = methods[i].getGenericParameterTypes();
+ UnresolvedType[] newPTypes = new UnresolvedType[ptypes.length];
+ for (int j = 0; j < ptypes.length; j++) {
+ if (ptypes[j] instanceof TypeVariableReferenceType) {
+ TypeVariableReferenceType tvrt = (TypeVariableReferenceType) ptypes[j];
+ if (typeVariableMap.containsKey(tvrt.getTypeVariable().getName())) {
+ newPTypes[j] = (UnresolvedType) typeVariableMap.get(tvrt.getTypeVariable().getName());
+ } else {
+ newPTypes[j] = ptypes[j];
+ }
+ } else {
+ newPTypes[j] = ptypes[j];
+ }
+ }
+ advice.setBindingParameterTypes(newPTypes);
+ }
+ }
+ munger.setDeclaringType(this);
+ l.add(munger);
+ }
+ }
+ return l;
+ }
+
+ public Collection getDeclaredShadowMungers() {
+ Collection c = getDeclaredAdvice();
+ return c;
+ }
+
+ // ---- only for testing!
+
+ public ResolvedMember[] getDeclaredJavaFields() {
+ return filterInJavaVisible(getDeclaredFields());
+ }
+
+ public ResolvedMember[] getDeclaredJavaMethods() {
+ return filterInJavaVisible(getDeclaredMethods());
+ }
+
+ public ShadowMunger[] getDeclaredShadowMungersArray() {
+ List l = (List) getDeclaredShadowMungers();
+ return (ShadowMunger[]) l.toArray(new ShadowMunger[l.size()]);
+ }
+
+ private ResolvedMember[] filterInJavaVisible(ResolvedMember[] ms) {
+ List l = new ArrayList();
+ for (int i = 0, len = ms.length; i < len; i++) {
+ if (!ms[i].isAjSynthetic() && ms[i].getAssociatedShadowMunger() == null) {
+ l.add(ms[i]);
+ }
+ }
+ return (ResolvedMember[]) l.toArray(new ResolvedMember[l.size()]);
+ }
+
+ public abstract ISourceContext getSourceContext();
+
+ // ---- fields
+
+ public static final ResolvedType[] NONE = new ResolvedType[0];
+
+ public static final Primitive BYTE = new Primitive("B", 1, 0);
+ public static final Primitive CHAR = new Primitive("C", 1, 1);
+ public static final Primitive DOUBLE = new Primitive("D", 2, 2);
+ public static final Primitive FLOAT = new Primitive("F", 1, 3);
+ public static final Primitive INT = new Primitive("I", 1, 4);
+ public static final Primitive LONG = new Primitive("J", 2, 5);
+ public static final Primitive SHORT = new Primitive("S", 1, 6);
+ public static final Primitive VOID = new Primitive("V", 0, 8);
+ public static final Primitive BOOLEAN = new Primitive("Z", 1, 7);
+ public static final Missing MISSING = new Missing();
+
+ /** Reset the static state in the primitive types */
+ // OPTIMIZE I think we have a bug here because primitives are static and the world they use may vary (or may even be
+ // null)
+ public static void resetPrimitives() {
+ BYTE.world = null;
+ CHAR.world = null;
+ DOUBLE.world = null;
+ FLOAT.world = null;
+ INT.world = null;
+ LONG.world = null;
+ SHORT.world = null;
+ VOID.world = null;
+ BOOLEAN.world = null;
+ }
+
+ // ---- types
+ public static ResolvedType makeArray(ResolvedType type, int dim) {
+ if (dim == 0)
+ return type;
+ ResolvedType array = new ArrayReferenceType("[" + type.getSignature(), "[" + type.getErasureSignature(), type.getWorld(),
+ type);
+ return makeArray(array, dim - 1);
+ }
+
+ static class Primitive extends ResolvedType {
+ private int size;
+ private int index;
+
+ Primitive(String signature, int size, int index) {
+ super(signature, null);
+ this.size = size;
+ this.index = index;
+ this.typeKind = TypeKind.PRIMITIVE;
+ }
+
+ public final int getSize() {
+ return size;
+ }
+
+ public final int getModifiers() {
+ return Modifier.PUBLIC | Modifier.FINAL;
+ }
+
+ public final boolean isPrimitiveType() {
+ return true;
+ }
+
+ public boolean hasAnnotation(UnresolvedType ofType) {
+ return false;
+ }
+
+ public final boolean isAssignableFrom(ResolvedType other) {
+ if (!other.isPrimitiveType()) {
+ if (!world.isInJava5Mode())
+ return false;
+ return validBoxing.contains(this.getSignature() + other.getSignature());
+ }
+ return assignTable[((Primitive) other).index][index];
+ }
+
+ public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) {
+ return isAssignableFrom(other);
+ }
+
+ public final boolean isCoerceableFrom(ResolvedType other) {
+ if (this == other)
+ return true;
+ if (!other.isPrimitiveType())
+ return false;
+ if (index > 6 || ((Primitive) other).index > 6)
+ return false;
+ return true;
+ }
+
+ public ResolvedType resolve(World world) {
+ this.world = world;
+ return super.resolve(world);
+ }
+
+ public final boolean needsNoConversionFrom(ResolvedType other) {
+ if (!other.isPrimitiveType())
+ return false;
+ return noConvertTable[((Primitive) other).index][index];
+ }
+
+ private static final boolean[][] assignTable = {// to: B C D F I J S V Z from
+ { true, true, true, true, true, true, true, false, false }, // B
+ { false, true, true, true, true, true, false, false, false }, // C
+ { false, false, true, false, false, false, false, false, false }, // D
+ { false, false, true, true, false, false, false, false, false }, // F
+ { false, false, true, true, true, true, false, false, false }, // I
+ { false, false, true, true, false, true, false, false, false }, // J
+ { false, false, true, true, true, true, true, false, false }, // S
+ { false, false, false, false, false, false, false, true, false }, // V
+ { false, false, false, false, false, false, false, false, true }, // Z
+ };
+ private static final boolean[][] noConvertTable = {// to: B C D F I J S V Z from
+ { true, true, false, false, true, false, true, false, false }, // B
+ { false, true, false, false, true, false, false, false, false }, // C
+ { false, false, true, false, false, false, false, false, false }, // D
+ { false, false, false, true, false, false, false, false, false }, // F
+ { false, false, false, false, true, false, false, false, false }, // I
+ { false, false, false, false, false, true, false, false, false }, // J
+ { false, false, false, false, true, false, true, false, false }, // S
+ { false, false, false, false, false, false, false, true, false }, // V
+ { false, false, false, false, false, false, false, false, true }, // Z
+ };
+
+ // ----
+
+ public final ResolvedMember[] getDeclaredFields() {
+ return ResolvedMember.NONE;
+ }
+
+ public final ResolvedMember[] getDeclaredMethods() {
+ return ResolvedMember.NONE;
+ }
+
+ public final ResolvedType[] getDeclaredInterfaces() {
+ return ResolvedType.NONE;
+ }
+
+ public final ResolvedMember[] getDeclaredPointcuts() {
+ return ResolvedMember.NONE;
+ }
+
+ public final ResolvedType getSuperclass() {
+ return null;
+ }
+
+ public ISourceContext getSourceContext() {
+ return null;
+ }
+
+ }
+
+ static class Missing extends ResolvedType {
+ Missing() {
+ super(MISSING_NAME, null);
+ }
+
+ // public final String toString() {
+ // return "<missing>";
+ // }
+ public final String getName() {
+ return MISSING_NAME;
+ }
+
+ public final boolean isMissing() {
+ return true;
+ }
+
+ public boolean hasAnnotation(UnresolvedType ofType) {
+ return false;
+ }
+
+ public final ResolvedMember[] getDeclaredFields() {
+ return ResolvedMember.NONE;
+ }
+
+ public final ResolvedMember[] getDeclaredMethods() {
+ return ResolvedMember.NONE;
+ }
+
+ public final ResolvedType[] getDeclaredInterfaces() {
+ return ResolvedType.NONE;
+ }
+
+ public final ResolvedMember[] getDeclaredPointcuts() {
+ return ResolvedMember.NONE;
+ }
+
+ public final ResolvedType getSuperclass() {
+ return null;
+ }
+
+ public final int getModifiers() {
+ return 0;
+ }
+
+ public final boolean isAssignableFrom(ResolvedType other) {
+ return false;
+ }
+
+ public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) {
+ return false;
+ }
-
- public Collection getDeclaredAdvice() {
- List l = new ArrayList();
- ResolvedMember[] methods = getDeclaredMethods();
- if (isParameterizedType()) methods = getGenericType().getDeclaredMethods();
- Map typeVariableMap = getAjMemberParameterizationMap();
- for (int i=0, len = methods.length; i < len; i++) {
- ShadowMunger munger = methods[i].getAssociatedShadowMunger();
- if (munger != null) {
- if (ajMembersNeedParameterization()) {
- //munger.setPointcut(munger.getPointcut().parameterizeWith(typeVariableMap));
- munger = munger.parameterizeWith(this,typeVariableMap);
- if (munger instanceof Advice) {
- Advice advice = (Advice) munger;
- // update to use the parameterized signature...
- UnresolvedType[] ptypes = methods[i].getGenericParameterTypes() ;
- UnresolvedType[] newPTypes = new UnresolvedType[ptypes.length];
- for (int j = 0; j < ptypes.length; j++) {
- if (ptypes[j] instanceof TypeVariableReferenceType) {
- TypeVariableReferenceType tvrt = (TypeVariableReferenceType) ptypes[j];
- if (typeVariableMap.containsKey(tvrt.getTypeVariable().getName())) {
- newPTypes[j] = (UnresolvedType) typeVariableMap.get(tvrt.getTypeVariable().getName());
- } else {
- newPTypes[j] = ptypes[j];
- }
- } else {
- newPTypes[j] = ptypes[j];
- }
- }
- advice.setBindingParameterTypes(newPTypes);
- }
- }
- munger.setDeclaringType(this);
- l.add(munger);
- }
+ public final boolean isCoerceableFrom(ResolvedType other) {
+ return false;
}
- return l;
- }
-
- public Collection getDeclaredShadowMungers() {
- Collection c = getDeclaredAdvice();
- return c;
- }
-
- // ---- only for testing!
+ public boolean needsNoConversionFrom(ResolvedType other) {
+ return false;
+ }
- public ResolvedMember[] getDeclaredJavaFields() {
- return filterInJavaVisible(getDeclaredFields());
- }
- public ResolvedMember[] getDeclaredJavaMethods() {
- return filterInJavaVisible(getDeclaredMethods());
- }
- public ShadowMunger[] getDeclaredShadowMungersArray() {
- List l = (List) getDeclaredShadowMungers();
- return (ShadowMunger[]) l.toArray(new ShadowMunger[l.size()]);
- }
- private ResolvedMember[] filterInJavaVisible(ResolvedMember[] ms) {
- List l = new ArrayList();
- for (int i=0, len = ms.length; i < len; i++) {
- if (! ms[i].isAjSynthetic() && ms[i].getAssociatedShadowMunger() == null) {
- l.add(ms[i]);
- }
+ public ISourceContext getSourceContext() {
+ return null;
}
- return (ResolvedMember[]) l.toArray(new ResolvedMember[l.size()]);
- }
-
- public abstract ISourceContext getSourceContext();
+ }
- // ---- fields
-
- public static final ResolvedType[] NONE = new ResolvedType[0];
-
- public static final Primitive BYTE = new Primitive("B", 1, 0);
- public static final Primitive CHAR = new Primitive("C", 1, 1);
- public static final Primitive DOUBLE = new Primitive("D", 2, 2);
- public static final Primitive FLOAT = new Primitive("F", 1, 3);
- public static final Primitive INT = new Primitive("I", 1, 4);
- public static final Primitive LONG = new Primitive("J", 2, 5);
- public static final Primitive SHORT = new Primitive("S", 1, 6);
- public static final Primitive VOID = new Primitive("V", 0, 8);
- public static final Primitive BOOLEAN = new Primitive("Z", 1, 7);
- public static final Missing MISSING = new Missing();
-
- /** Reset the static state in the primitive types */
- // OPTIMIZE I think we have a bug here because primitives are static and the world they use may vary (or may even be
- // null)
- public static void resetPrimitives() {
- BYTE.world=null;
- CHAR.world=null;
- DOUBLE.world=null;
- FLOAT.world=null;
- INT.world=null;
- LONG.world=null;
- SHORT.world=null;
- VOID.world=null;
- BOOLEAN.world=null;
- }
-
-
- // ---- types
- public static ResolvedType makeArray(ResolvedType type, int dim) {
- if (dim == 0) return type;
- ResolvedType array = new ArrayReferenceType("[" + type.getSignature(),"["+type.getErasureSignature(),type.getWorld(),type);
- return makeArray(array,dim-1);
- }
-
- static class Array extends ResolvedType {
- ResolvedType componentType;
-
-
- // Sometimes the erasure is different, eg. [TT; and [Ljava/lang/Object;
- Array(String sig, String erasureSig,World world, ResolvedType componentType) {
- super(sig,erasureSig, world);
- this.componentType = componentType;
- }
- public final ResolvedMember[] getDeclaredFields() {
- return ResolvedMember.NONE;
- }
- public final ResolvedMember[] getDeclaredMethods() {
- // ??? should this return clone? Probably not...
- // If it ever does, here is the code:
- // ResolvedMember cloneMethod =
- // new ResolvedMember(Member.METHOD,this,Modifier.PUBLIC,UnresolvedType.OBJECT,"clone",new UnresolvedType[]{});
- // return new ResolvedMember[]{cloneMethod};
- return ResolvedMember.NONE;
- }
- public final ResolvedType[] getDeclaredInterfaces() {
- return
- new ResolvedType[] {
- world.getCoreType(CLONEABLE),
- world.getCoreType(SERIALIZABLE)
- };
- }
- public final ResolvedMember[] getDeclaredPointcuts() {
- return ResolvedMember.NONE;
- }
-
- public boolean hasAnnotation(UnresolvedType ofType) {
- return false;
- }
-
- public final ResolvedType getSuperclass() {
- return world.getCoreType(OBJECT);
- }
- public final boolean isAssignableFrom(ResolvedType o) {
- if (! o.isArray()) return false;
- if (o.getComponentType().isPrimitiveType()) {
- return o.equals(this);
- } else {
- return getComponentType().resolve(world).isAssignableFrom(o.getComponentType().resolve(world));
- }
- }
-
- public boolean isAssignableFrom(ResolvedType o, boolean allowMissing) {
- return isAssignableFrom(o);
- }
-
- public final boolean isCoerceableFrom(ResolvedType o) {
- if (o.equals(UnresolvedType.OBJECT) ||
- o.equals(UnresolvedType.SERIALIZABLE) ||
- o.equals(UnresolvedType.CLONEABLE)) {
- return true;
- }
- if (! o.isArray()) return false;
- if (o.getComponentType().isPrimitiveType()) {
- return o.equals(this);
- } else {
- return getComponentType().resolve(world).isCoerceableFrom(o.getComponentType().resolve(world));
- }
- }
- public final int getModifiers() {
- int mask = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED;
- return (componentType.getModifiers() & mask) | Modifier.FINAL;
- }
- public UnresolvedType getComponentType() {
- return componentType;
- }
- public ResolvedType getResolvedComponentType() {
- return componentType;
- }
- public ISourceContext getSourceContext() {
- return getResolvedComponentType().getSourceContext();
- }
- }
-
- static class Primitive extends ResolvedType {
- private int size;
- private int index;
- Primitive(String signature, int size, int index) {
- super(signature, null);
- this.size = size;
- this.index = index;
- this.typeKind=TypeKind.PRIMITIVE;
- }
- public final int getSize() {
- return size;
- }
- public final int getModifiers() {
- return Modifier.PUBLIC | Modifier.FINAL;
- }
- public final boolean isPrimitiveType() {
- return true;
- }
- public boolean hasAnnotation(UnresolvedType ofType) {
- return false;
- }
- public final boolean isAssignableFrom(ResolvedType other) {
- if (!other.isPrimitiveType()) {
- if (!world.isInJava5Mode()) return false;
- return validBoxing.contains(this.getSignature()+other.getSignature());
- }
- return assignTable[((Primitive)other).index][index];
- }
- public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) {
- return isAssignableFrom(other);
- }
- public final boolean isCoerceableFrom(ResolvedType other) {
- if (this == other) return true;
- if (! other.isPrimitiveType()) return false;
- if (index > 6 || ((Primitive)other).index > 6) return false;
- return true;
- }
- public ResolvedType resolve(World world) {
- this.world = world;
- return super.resolve(world);
- }
- public final boolean needsNoConversionFrom(ResolvedType other) {
- if (! other.isPrimitiveType()) return false;
- return noConvertTable[((Primitive)other).index][index];
- }
- private static final boolean[][] assignTable =
- {// to: B C D F I J S V Z from
- { true , true , true , true , true , true , true , false, false }, // B
- { false, true , true , true , true , true , false, false, false }, // C
- { false, false, true , false, false, false, false, false, false }, // D
- { false, false, true , true , false, false, false, false, false }, // F
- { false, false, true , true , true , true , false, false, false }, // I
- { false, false, true , true , false, true , false, false, false }, // J
- { false, false, true , true , true , true , true , false, false }, // S
- { false, false, false, false, false, false, false, true , false }, // V
- { false, false, false, false, false, false, false, false, true }, // Z
- };
- private static final boolean[][] noConvertTable =
- {// to: B C D F I J S V Z from
- { true , true , false, false, true , false, true , false, false }, // B
- { false, true , false, false, true , false, false, false, false }, // C
- { false, false, true , false, false, false, false, false, false }, // D
- { false, false, false, true , false, false, false, false, false }, // F
- { false, false, false, false, true , false, false, false, false }, // I
- { false, false, false, false, false, true , false, false, false }, // J
- { false, false, false, false, true , false, true , false, false }, // S
- { false, false, false, false, false, false, false, true , false }, // V
- { false, false, false, false, false, false, false, false, true }, // Z
- };
-
- // ----
-
- public final ResolvedMember[] getDeclaredFields() {
- return ResolvedMember.NONE;
- }
- public final ResolvedMember[] getDeclaredMethods() {
- return ResolvedMember.NONE;
- }
- public final ResolvedType[] getDeclaredInterfaces() {
- return ResolvedType.NONE;
- }
- public final ResolvedMember[] getDeclaredPointcuts() {
- return ResolvedMember.NONE;
- }
-
- public final ResolvedType getSuperclass() {
- return null;
- }
-
- public ISourceContext getSourceContext() {
- return null;
- }
-
- }
-
- static class Missing extends ResolvedType {
- Missing() {
- super(MISSING_NAME, null);
- }
-// public final String toString() {
-// return "<missing>";
-// }
- public final String getName() {
- return MISSING_NAME;
- }
-
- public final boolean isMissing() {
- return true;
- }
-
- public boolean hasAnnotation(UnresolvedType ofType) {
- return false;
- }
- public final ResolvedMember[] getDeclaredFields() {
- return ResolvedMember.NONE;
- }
- public final ResolvedMember[] getDeclaredMethods() {
- return ResolvedMember.NONE;
- }
- public final ResolvedType[] getDeclaredInterfaces() {
- return ResolvedType.NONE;
- }
-
- public final ResolvedMember[] getDeclaredPointcuts() {
- return ResolvedMember.NONE;
- }
- public final ResolvedType getSuperclass() {
- return null;
- }
- public final int getModifiers() {
- return 0;
- }
- public final boolean isAssignableFrom(ResolvedType other) {
- return false;
- }
- public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) {
- return false;
- }
- public final boolean isCoerceableFrom(ResolvedType other) {
- return false;
- }
- public boolean needsNoConversionFrom(ResolvedType other) {
- return false;
- }
- public ISourceContext getSourceContext() {
- return null;
- }
-
- }
-
- /**
- * Look up a member, takes into account any ITDs on this type.
- * return null if not found
- */
+ /**
+ * Look up a member, takes into account any ITDs on this type. return null if not found
+ */
public ResolvedMember lookupMemberNoSupers(Member member) {
ResolvedMember ret = lookupDirectlyDeclaredMemberNoSupers(member);
if (ret == null && interTypeMungers != null) {
}
return ret;
}
-
+
public ResolvedMember lookupMemberWithSupersAndITDs(Member member) {
ResolvedMember ret = lookupMemberNoSupers(member);
- if (ret != null) return ret;
-
+ if (ret != null)
+ return ret;
+
ResolvedType supert = getSuperclass();
- while (ret==null && supert!=null) {
+ while (ret == null && supert != null) {
ret = supert.lookupMemberNoSupers(member);
- if (ret==null) supert = supert.getSuperclass();
+ if (ret == null)
+ supert = supert.getSuperclass();
}
-
+
return ret;
}
-
+
/**
* as lookupMemberNoSupers, but does not include ITDs
- *
+ *
* @param member
* @return
*/
}
return ret;
}
-
+
/**
- * This lookup has specialized behaviour - a null result tells the
- * EclipseTypeMunger that it should make a default implementation of a
- * method on this type.
- *
+ * This lookup has specialized behaviour - a null result tells the EclipseTypeMunger that it should make a default
+ * implementation of a method on this type.
+ *
* @param member
* @return
*/
public ResolvedMember lookupMemberIncludingITDsOnInterfaces(Member member) {
return lookupMemberIncludingITDsOnInterfaces(member, this);
}
-
+
private ResolvedMember lookupMemberIncludingITDsOnInterfaces(Member member, ResolvedType onType) {
ResolvedMember ret = onType.lookupMemberNoSupers(member);
if (ret != null) {
} else {
ResolvedType superType = onType.getSuperclass();
if (superType != null) {
- ret = lookupMemberIncludingITDsOnInterfaces(member,superType);
+ ret = lookupMemberIncludingITDsOnInterfaces(member, superType);
}
if (ret == null) {
// try interfaces then, but only ITDs now...
ResolvedType[] superInterfaces = onType.getDeclaredInterfaces();
for (int i = 0; i < superInterfaces.length; i++) {
ret = superInterfaces[i].lookupMethodInITDs(member);
- if (ret != null) return ret;
+ if (ret != null)
+ return ret;
}
}
}
return ret;
}
-
+
protected List interTypeMungers = new ArrayList(0);
-
+
public List getInterTypeMungers() {
return interTypeMungers;
}
-
- public List getInterTypeParentMungers() {
- List l = new ArrayList();
- for (Iterator iter = interTypeMungers.iterator(); iter.hasNext();) {
- ConcreteTypeMunger element = (ConcreteTypeMunger) iter.next();
- if (element.getMunger() instanceof NewParentTypeMunger) l.add(element);
+
+ public List getInterTypeParentMungers() {
+ List l = new ArrayList();
+ for (Iterator iter = interTypeMungers.iterator(); iter.hasNext();) {
+ ConcreteTypeMunger element = (ConcreteTypeMunger) iter.next();
+ if (element.getMunger() instanceof NewParentTypeMunger)
+ l.add(element);
+ }
+ return l;
}
- return l;
- }
-
+
/**
- * ??? This method is O(N*M) where N = number of methods and M is number of
- * inter-type declarations in my super
+ * ??? This method is O(N*M) where N = number of methods and M is number of inter-type declarations in my super
*/
- public List getInterTypeMungersIncludingSupers() {
- ArrayList ret = new ArrayList();
- collectInterTypeMungers(ret);
- return ret;
- }
-
-
- public List getInterTypeParentMungersIncludingSupers() {
- ArrayList ret = new ArrayList();
- collectInterTypeParentMungers(ret);
- return ret;
- }
-
- private void collectInterTypeParentMungers(List collector) {
- for (Iterator iter = getDirectSupertypes(); iter.hasNext();) {
- ResolvedType superType = (ResolvedType) iter.next();
- superType.collectInterTypeParentMungers(collector);
- }
- collector.addAll(getInterTypeParentMungers());
- }
-
-
- protected void collectInterTypeMungers(List collector) {
- for (Iterator iter = getDirectSupertypes(); iter.hasNext();) {
+ public List getInterTypeMungersIncludingSupers() {
+ ArrayList ret = new ArrayList();
+ collectInterTypeMungers(ret);
+ return ret;
+ }
+
+ public List getInterTypeParentMungersIncludingSupers() {
+ ArrayList ret = new ArrayList();
+ collectInterTypeParentMungers(ret);
+ return ret;
+ }
+
+ private void collectInterTypeParentMungers(List collector) {
+ for (Iterator iter = getDirectSupertypes(); iter.hasNext();) {
+ ResolvedType superType = (ResolvedType) iter.next();
+ superType.collectInterTypeParentMungers(collector);
+ }
+ collector.addAll(getInterTypeParentMungers());
+ }
+
+ protected void collectInterTypeMungers(List collector) {
+ for (Iterator iter = getDirectSupertypes(); iter.hasNext();) {
ResolvedType superType = (ResolvedType) iter.next();
if (superType == null) {
- throw new BCException("UnexpectedProblem: a supertype in the hierarchy for " + this.getName() + " is null");
- }
- superType.collectInterTypeMungers(collector);
- }
-
- outer:
- for (Iterator iter1 = collector.iterator(); iter1.hasNext();) {
- ConcreteTypeMunger superMunger = (ConcreteTypeMunger) iter1.next();
- if ( superMunger.getSignature() == null) continue;
-
- if ( !superMunger.getSignature().isAbstract()) continue;
-
- for (Iterator iter = getInterTypeMungers().iterator(); iter.hasNext();) {
- ConcreteTypeMunger myMunger = (ConcreteTypeMunger) iter.next();
- if (conflictingSignature(myMunger.getSignature(), superMunger.getSignature())) {
- iter1.remove();
- continue outer;
- }
- }
-
- if (!superMunger.getSignature().isPublic()) continue;
-
- for (Iterator iter = getMethods(); iter.hasNext(); ) {
- ResolvedMember method = (ResolvedMember)iter.next();
- if (conflictingSignature(method, superMunger.getSignature())) {
- iter1.remove();
- continue outer;
- }
- }
- }
-
- collector.addAll(getInterTypeMungers());
- }
-
-
-
- /**
- * Check:
- * 1) That we don't have any abstract type mungers unless this type is abstract.
- * 2) That an abstract ITDM on an interface is declared public. (Compiler limitation) (PR70794)
- */
- public void checkInterTypeMungers() {
- if (isAbstract()) return;
-
- boolean itdProblem = false;
-
- for (Iterator iter = getInterTypeMungersIncludingSupers().iterator(); iter.hasNext();) {
+ throw new BCException("UnexpectedProblem: a supertype in the hierarchy for " + this.getName() + " is null");
+ }
+ superType.collectInterTypeMungers(collector);
+ }
+
+ outer: for (Iterator iter1 = collector.iterator(); iter1.hasNext();) {
+ ConcreteTypeMunger superMunger = (ConcreteTypeMunger) iter1.next();
+ if (superMunger.getSignature() == null)
+ continue;
+
+ if (!superMunger.getSignature().isAbstract())
+ continue;
+
+ for (Iterator iter = getInterTypeMungers().iterator(); iter.hasNext();) {
+ ConcreteTypeMunger myMunger = (ConcreteTypeMunger) iter.next();
+ if (conflictingSignature(myMunger.getSignature(), superMunger.getSignature())) {
+ iter1.remove();
+ continue outer;
+ }
+ }
+
+ if (!superMunger.getSignature().isPublic())
+ continue;
+
+ for (Iterator iter = getMethods(); iter.hasNext();) {
+ ResolvedMember method = (ResolvedMember) iter.next();
+ if (conflictingSignature(method, superMunger.getSignature())) {
+ iter1.remove();
+ continue outer;
+ }
+ }
+ }
+
+ collector.addAll(getInterTypeMungers());
+ }
+
+ /**
+ * Check: 1) That we don't have any abstract type mungers unless this type is abstract. 2) That an abstract ITDM on an interface
+ * is declared public. (Compiler limitation) (PR70794)
+ */
+ public void checkInterTypeMungers() {
+ if (isAbstract())
+ return;
+
+ boolean itdProblem = false;
+
+ for (Iterator iter = getInterTypeMungersIncludingSupers().iterator(); iter.hasNext();) {
ConcreteTypeMunger munger = (ConcreteTypeMunger) iter.next();
itdProblem = checkAbstractDeclaration(munger) || itdProblem; // Rule 2
- }
-
- if (itdProblem) return; // If the rules above are broken, return right now
-
+ }
+
+ if (itdProblem)
+ return; // If the rules above are broken, return right now
+
for (Iterator iter = getInterTypeMungersIncludingSupers().iterator(); iter.hasNext();) {
ConcreteTypeMunger munger = (ConcreteTypeMunger) iter.next();
- if (munger.getSignature() != null && munger.getSignature().isAbstract()) { // Rule 1
- if (munger.getMunger().getKind() == ResolvedTypeMunger.MethodDelegate) {
- //ignore for @AJ ITD as munger.getSignature() is the interface method hence abstract
- } else {
- world.getMessageHandler().handleMessage(
- new Message("must implement abstract inter-type declaration: " + munger.getSignature(),
- "", IMessage.ERROR, getSourceLocation(), null,
- new ISourceLocation[] { getMungerLocation(munger) }));
- }
- }
- }
- }
-
- /**
- * See PR70794. This method checks that if an abstract inter-type method declaration is made on
- * an interface then it must also be public.
- * This is a compiler limitation that could be made to work in the future (if someone
- * provides a worthwhile usecase)
- *
- * @return indicates if the munger failed the check
- */
- private boolean checkAbstractDeclaration(ConcreteTypeMunger munger) {
- if (munger.getMunger()!=null && (munger.getMunger() instanceof NewMethodTypeMunger)) {
+ if (munger.getSignature() != null && munger.getSignature().isAbstract()) { // Rule 1
+ if (munger.getMunger().getKind() == ResolvedTypeMunger.MethodDelegate) {
+ // ignore for @AJ ITD as munger.getSignature() is the interface method hence abstract
+ } else {
+ world.getMessageHandler()
+ .handleMessage(
+ new Message("must implement abstract inter-type declaration: " + munger.getSignature(), "",
+ IMessage.ERROR, getSourceLocation(), null,
+ new ISourceLocation[] { getMungerLocation(munger) }));
+ }
+ }
+ }
+ }
+
+ /**
+ * See PR70794. This method checks that if an abstract inter-type method declaration is made on an interface then it must also
+ * be public. This is a compiler limitation that could be made to work in the future (if someone provides a worthwhile usecase)
+ *
+ * @return indicates if the munger failed the check
+ */
+ private boolean checkAbstractDeclaration(ConcreteTypeMunger munger) {
+ if (munger.getMunger() != null && (munger.getMunger() instanceof NewMethodTypeMunger)) {
ResolvedMember itdMember = munger.getSignature();
ResolvedType onType = itdMember.getDeclaringType().resolve(world);
if (onType.isInterface() && itdMember.isAbstract() && !itdMember.isPublic()) {
- world.getMessageHandler().handleMessage(
- new Message(WeaverMessages.format(WeaverMessages.ITD_ABSTRACT_MUST_BE_PUBLIC_ON_INTERFACE,munger.getSignature(),onType),"",
- Message.ERROR,getSourceLocation(),null,
- new ISourceLocation[]{getMungerLocation(munger)})
- );
- return true;
- }
+ world.getMessageHandler().handleMessage(
+ new Message(WeaverMessages.format(WeaverMessages.ITD_ABSTRACT_MUST_BE_PUBLIC_ON_INTERFACE, munger
+ .getSignature(), onType), "", Message.ERROR, getSourceLocation(), null,
+ new ISourceLocation[] { getMungerLocation(munger) }));
+ return true;
+ }
}
return false;
- }
-
- /**
- * Get a source location for the munger.
- * Until intertype mungers remember where they came from, the source location
- * for the munger itself is null. In these cases use the
- * source location for the aspect containing the ITD.
- */
- private ISourceLocation getMungerLocation(ConcreteTypeMunger munger) {
- ISourceLocation sloc = munger.getSourceLocation();
- if (sloc == null) {
- sloc = munger.getAspectType().getSourceLocation();
- }
- return sloc;
- }
-
- /**
- * Returns a ResolvedType object representing the declaring type of this type, or
- * null if this type does not represent a non-package-level-type.
- * <p/>
- * <strong>Warning</strong>: This is guaranteed to work for all member types.
- * For anonymous/local types, the only guarantee is given in JLS 13.1, where
- * it guarantees that if you call getDeclaringType() repeatedly, you will eventually
- * get the top-level class, but it does not say anything about classes in between.
- *
- * @return the declaring UnresolvedType object, or null.
- */
- public ResolvedType getDeclaringType() {
- if (isArray()) return null;
+ }
+
+ /**
+ * Get a source location for the munger. Until intertype mungers remember where they came from, the source location for the
+ * munger itself is null. In these cases use the source location for the aspect containing the ITD.
+ */
+ private ISourceLocation getMungerLocation(ConcreteTypeMunger munger) {
+ ISourceLocation sloc = munger.getSourceLocation();
+ if (sloc == null) {
+ sloc = munger.getAspectType().getSourceLocation();
+ }
+ return sloc;
+ }
+
+ /**
+ * Returns a ResolvedType object representing the declaring type of this type, or null if this type does not represent a
+ * non-package-level-type. <p/> <strong>Warning</strong>: This is guaranteed to work for all member types. For anonymous/local
+ * types, the only guarantee is given in JLS 13.1, where it guarantees that if you call getDeclaringType() repeatedly, you will
+ * eventually get the top-level class, but it does not say anything about classes in between.
+ *
+ * @return the declaring UnresolvedType object, or null.
+ */
+ public ResolvedType getDeclaringType() {
+ if (isArray())
+ return null;
String name = getName();
int lastDollar = name.lastIndexOf('$');
- while (lastDollar >0) { // allow for classes starting '$' (pr120474)
+ while (lastDollar > 0) { // allow for classes starting '$' (pr120474)
ResolvedType ret = world.resolve(UnresolvedType.forName(name.substring(0, lastDollar)), true);
- if (!ResolvedType.isMissing(ret)) return ret;
- lastDollar = name.lastIndexOf('$', lastDollar-1);
+ if (!ResolvedType.isMissing(ret))
+ return ret;
+ lastDollar = name.lastIndexOf('$', lastDollar - 1);
}
return null;
- }
-
-
+ }
+
public static boolean isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType) {
- //System.err.println("mod: " + modifiers + ", " + targetType + " and " + fromType);
-
+ // System.err.println("mod: " + modifiers + ", " + targetType + " and " + fromType);
+
if (Modifier.isPublic(modifiers)) {
return true;
} else if (Modifier.isPrivate(modifiers)) {
return samePackage(targetType, fromType) || targetType.isAssignableFrom(fromType);
} else { // package-visible
return samePackage(targetType, fromType);
- }
+ }
}
-
+
public static boolean hasBridgeModifier(int modifiers) {
- return (modifiers & Constants.ACC_BRIDGE)!=0;
+ return (modifiers & Constants.ACC_BRIDGE) != 0;
}
- private static boolean samePackage(
- ResolvedType targetType,
- ResolvedType fromType) {
+ private static boolean samePackage(ResolvedType targetType, ResolvedType fromType) {
String p1 = targetType.getPackageName();
String p2 = fromType.getPackageName();
- if (p1 == null) return p2 == null;
- if (p2 == null) return false;
+ if (p1 == null)
+ return p2 == null;
+ if (p2 == null)
+ return false;
return p1.equals(p2);
}
/**
- * Checks if the generic type for 'this' and the generic type for 'other' are the same -
- * it can be passed raw or parameterized versions and will just compare the underlying
- * generic type.
+ * Checks if the generic type for 'this' and the generic type for 'other' are the same - it can be passed raw or parameterized
+ * versions and will just compare the underlying generic type.
+ */
+ private boolean genericTypeEquals(ResolvedType other) {
+ ResolvedType rt = other;
+ if (rt.isParameterizedType() || rt.isRawType())
+ rt.getGenericType();
+ if (((isParameterizedType() || isRawType()) && getGenericType().equals(rt)) || (this.equals(other)))
+ return true;
+ return false;
+ }
+
+ /**
+ * Look up the actual occurence of a particular type in the hierarchy for 'this' type. The input is going to be a generic type,
+ * and the caller wants to know if it was used in its RAW or a PARAMETERIZED form in this hierarchy.
+ *
+ * returns null if it can't be found.
+ */
+ public ResolvedType discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor) {
+ if (!lookingFor.isGenericType())
+ throw new BCException("assertion failed: method should only be called with generic type, but " + lookingFor + " is "
+ + lookingFor.typeKind);
+
+ if (this.equals(ResolvedType.OBJECT))
+ return null;
+
+ if (genericTypeEquals(lookingFor))
+ return this;
+
+ ResolvedType superT = getSuperclass();
+ if (superT.genericTypeEquals(lookingFor))
+ return superT;
+
+ ResolvedType[] superIs = getDeclaredInterfaces();
+ for (int i = 0; i < superIs.length; i++) {
+ ResolvedType superI = superIs[i];
+ if (superI.genericTypeEquals(lookingFor))
+ return superI;
+ ResolvedType checkTheSuperI = superI.discoverActualOccurrenceOfTypeInHierarchy(lookingFor);
+ if (checkTheSuperI != null)
+ return checkTheSuperI;
+ }
+ return superT.discoverActualOccurrenceOfTypeInHierarchy(lookingFor);
+ }
+
+ /**
+ * Called for all type mungers but only does something if they share type variables with a generic type which they target. When
+ * this happens this routine will check for the target type in the target hierarchy and 'bind' any type parameters as
+ * appropriate. For example, for the ITD "List<T> I<T>.x" against a type like this: "class A implements I<String>" this routine
+ * will return a parameterized form of the ITD "List<String> I.x"
*/
- private boolean genericTypeEquals(ResolvedType other) {
- ResolvedType rt = other;
- if (rt.isParameterizedType() || rt.isRawType()) rt.getGenericType();
- if (( (isParameterizedType() || isRawType()) && getGenericType().equals(rt)) ||
- (this.equals(other))) return true;
- return false;
- }
-
- /**
- * Look up the actual occurence of a particular type in the hierarchy for
- * 'this' type. The input is going to be a generic type, and the caller
- * wants to know if it was used in its RAW or a PARAMETERIZED form in this
- * hierarchy.
- *
- * returns null if it can't be found.
- */
- public ResolvedType discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor) {
- if (!lookingFor.isGenericType())
- throw new BCException("assertion failed: method should only be called with generic type, but "+lookingFor+" is "+lookingFor.typeKind);
-
- if (this.equals(ResolvedType.OBJECT)) return null;
-
- if (genericTypeEquals(lookingFor)) return this;
-
- ResolvedType superT = getSuperclass();
- if (superT.genericTypeEquals(lookingFor)) return superT;
-
- ResolvedType[] superIs = getDeclaredInterfaces();
- for (int i = 0; i < superIs.length; i++) {
- ResolvedType superI = superIs[i];
- if (superI.genericTypeEquals(lookingFor)) return superI;
- ResolvedType checkTheSuperI = superI.discoverActualOccurrenceOfTypeInHierarchy(lookingFor);
- if (checkTheSuperI!=null) return checkTheSuperI;
- }
- return superT.discoverActualOccurrenceOfTypeInHierarchy(lookingFor);
- }
-
- /**
- * Called for all type mungers but only does something if they share type variables
- * with a generic type which they target. When this happens this routine will check
- * for the target type in the target hierarchy and 'bind' any type parameters as
- * appropriate. For example, for the ITD "List<T> I<T>.x" against a type like this:
- * "class A implements I<String>" this routine will return a parameterized form of
- * the ITD "List<String> I.x"
- */
- public ConcreteTypeMunger fillInAnyTypeParameters(ConcreteTypeMunger munger) {
- boolean debug = false;
+ public ConcreteTypeMunger fillInAnyTypeParameters(ConcreteTypeMunger munger) {
+ boolean debug = false;
ResolvedMember member = munger.getSignature();
if (munger.isTargetTypeParameterized()) {
- if (debug) System.err.println("Processing attempted parameterization of "+munger+" targetting type "+this);
- if (debug) System.err.println(" This type is "+this+" ("+typeKind+")");
- // need to tailor this munger instance for the particular target...
- if (debug) System.err.println(" Signature that needs parameterizing: "+member);
- // Retrieve the generic type
- ResolvedType onType = world.resolve(member.getDeclaringType()).getGenericType();
- member.resolve(world); // Ensure all parts of the member are resolved
- if (debug) System.err.println(" Actual target ontype: "+onType+" ("+onType.typeKind+")");
- // quickly find the targettype in the type hierarchy for this type (it will be either RAW or PARAMETERIZED)
- ResolvedType actualTarget = discoverActualOccurrenceOfTypeInHierarchy(onType);
- if (actualTarget==null)
- throw new BCException("assertion failed: asked "+this+" for occurrence of "+onType+" in its hierarchy??");
-
- // only bind the tvars if its a parameterized type or the raw type (in which case they collapse to bounds) - don't do it for generic types ;)
- if (!actualTarget.isGenericType()) {
- if (debug) System.err.println("Occurrence in "+this+" is actually "+actualTarget+" ("+actualTarget.typeKind+")");
- // parameterize the signature
- // ResolvedMember newOne = member.parameterizedWith(actualTarget.getTypeParameters(),onType,actualTarget.isParameterizedType());
- }
- //if (!actualTarget.isRawType())
- munger = munger.parameterizedFor(actualTarget);
- if (debug) System.err.println("New sig: "+munger.getSignature());
-
-
- if (debug) System.err.println("=====================================");
+ if (debug)
+ System.err.println("Processing attempted parameterization of " + munger + " targetting type " + this);
+ if (debug)
+ System.err.println(" This type is " + this + " (" + typeKind + ")");
+ // need to tailor this munger instance for the particular target...
+ if (debug)
+ System.err.println(" Signature that needs parameterizing: " + member);
+ // Retrieve the generic type
+ ResolvedType onType = world.resolve(member.getDeclaringType()).getGenericType();
+ member.resolve(world); // Ensure all parts of the member are resolved
+ if (debug)
+ System.err.println(" Actual target ontype: " + onType + " (" + onType.typeKind + ")");
+ // quickly find the targettype in the type hierarchy for this type (it will be either RAW or PARAMETERIZED)
+ ResolvedType actualTarget = discoverActualOccurrenceOfTypeInHierarchy(onType);
+ if (actualTarget == null)
+ throw new BCException("assertion failed: asked " + this + " for occurrence of " + onType + " in its hierarchy??");
+
+ // only bind the tvars if its a parameterized type or the raw type (in which case they collapse to bounds) - don't do it
+ // for generic types ;)
+ if (!actualTarget.isGenericType()) {
+ if (debug)
+ System.err.println("Occurrence in " + this + " is actually " + actualTarget + " (" + actualTarget.typeKind
+ + ")");
+ // parameterize the signature
+ // ResolvedMember newOne =
+ // member.parameterizedWith(actualTarget.getTypeParameters(),onType,actualTarget.isParameterizedType());
+ }
+ // if (!actualTarget.isRawType())
+ munger = munger.parameterizedFor(actualTarget);
+ if (debug)
+ System.err.println("New sig: " + munger.getSignature());
+
+ if (debug)
+ System.err.println("=====================================");
}
return munger;
- }
+ }
-
-
public void addInterTypeMunger(ConcreteTypeMunger munger) {
ResolvedMember sig = munger.getSignature();
- if (sig == null || munger.getMunger() == null ||
- munger.getMunger().getKind() == ResolvedTypeMunger.PrivilegedAccess)
- {
+ if (sig == null || munger.getMunger() == null || munger.getMunger().getKind() == ResolvedTypeMunger.PrivilegedAccess) {
interTypeMungers.add(munger);
return;
}
-
-// ConcreteTypeMunger originalMunger = munger;
+
+ // ConcreteTypeMunger originalMunger = munger;
// we will use the 'parameterized' ITD for all the comparisons but we say the original
- // one passed in actually matched as it will be added to the intertype member finder
- // for the target type. It is possible we only want to do this if a generic type
+ // one passed in actually matched as it will be added to the intertype member finder
+ // for the target type. It is possible we only want to do this if a generic type
// is discovered and the tvar is collapsed to a bound?
munger = fillInAnyTypeParameters(munger);
sig = munger.getSignature(); // possibly changed when type parms filled in
-
- //System.err.println("add: " + munger + " to " + this.getClassName() + " with " + interTypeMungers);
+ // System.err.println("add: " + munger + " to " + this.getClassName() + " with " + interTypeMungers);
if (sig.getKind() == Member.METHOD) {
- if (!compareToExistingMembers(munger, getMethodsWithoutIterator(false,true) /*getMethods()*/)) return;
+ if (!compareToExistingMembers(munger, getMethodsWithoutIterator(false, true) /* getMethods() */))
+ return;
if (this.isInterface()) {
- if (!compareToExistingMembers(munger,
- Arrays.asList(world.getCoreType(OBJECT).getDeclaredMethods()).iterator())) return;
+ if (!compareToExistingMembers(munger, Arrays.asList(world.getCoreType(OBJECT).getDeclaredMethods()).iterator()))
+ return;
}
} else if (sig.getKind() == Member.FIELD) {
- if (!compareToExistingMembers(munger, Arrays.asList(getDeclaredFields()).iterator())) return;
+ if (!compareToExistingMembers(munger, Arrays.asList(getDeclaredFields()).iterator()))
+ return;
} else {
- if (!compareToExistingMembers(munger, Arrays.asList(getDeclaredMethods()).iterator())) return;
+ if (!compareToExistingMembers(munger, Arrays.asList(getDeclaredMethods()).iterator()))
+ return;
}
-
// now compare to existingMungers
- for (Iterator i = interTypeMungers.iterator(); i.hasNext(); ) {
- ConcreteTypeMunger existingMunger = (ConcreteTypeMunger)i.next();
+ for (Iterator i = interTypeMungers.iterator(); i.hasNext();) {
+ ConcreteTypeMunger existingMunger = (ConcreteTypeMunger) i.next();
if (conflictingSignature(existingMunger.getSignature(), munger.getSignature())) {
- //System.err.println("match " + munger + " with " + existingMunger);
- if (isVisible(munger.getSignature().getModifiers(),
- munger.getAspectType(), existingMunger.getAspectType()))
- {
- //System.err.println(" is visible");
+ // System.err.println("match " + munger + " with " + existingMunger);
+ if (isVisible(munger.getSignature().getModifiers(), munger.getAspectType(), existingMunger.getAspectType())) {
+ // System.err.println(" is visible");
int c = compareMemberPrecedence(sig, existingMunger.getSignature());
if (c == 0) {
c = getWorld().compareByPrecedenceAndHierarchy(munger.getAspectType(), existingMunger.getAspectType());
}
- //System.err.println(" compare: " + c);
+ // System.err.println(" compare: " + c);
if (c < 0) {
// the existing munger dominates the new munger
checkLegalOverride(munger.getSignature(), existingMunger.getSignature());
interTypeConflictError(munger, existingMunger);
interTypeConflictError(existingMunger, munger);
return;
- }
+ }
}
}
}
- //System.err.println("adding: " + munger + " to " + this);
+ // System.err.println("adding: " + munger + " to " + this);
// we are adding the parameterized form of the ITD to the list of
- // mungers. Within it, the munger knows the original declared
+ // mungers. Within it, the munger knows the original declared
// signature for the ITD so it can be retrieved.
interTypeMungers.add(munger);
}
-
+
private boolean compareToExistingMembers(ConcreteTypeMunger munger, List existingMembersList) {
- return compareToExistingMembers(munger,existingMembersList.iterator());
+ return compareToExistingMembers(munger, existingMembersList.iterator());
}
-
- //??? returning too soon
+
+ // ??? returning too soon
private boolean compareToExistingMembers(ConcreteTypeMunger munger, Iterator existingMembers) {
ResolvedMember sig = munger.getSignature();
-
-// ResolvedType declaringAspectType = munger.getAspectType();
-// if (declaringAspectType.isRawType()) declaringAspectType = declaringAspectType.getGenericType();
-// if (declaringAspectType.isGenericType()) {
-//
-// ResolvedType genericOnType = getWorld().resolve(sig.getDeclaringType()).getGenericType();
-// ConcreteTypeMunger ctm = munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy(genericOnType));
-// sig = ctm.getSignature(); // possible sig change when type
-// }
-// if (munger.getMunger().hasTypeVariableAliases()) {
-// ResolvedType genericOnType =
-// getWorld().resolve(sig.getDeclaringType()).getGenericType();
-// ConcreteTypeMunger ctm =
-// munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy(genericOnType));
-// sig = ctm.getSignature(); // possible sig change when type parameters filled in
-// }
+
+ // ResolvedType declaringAspectType = munger.getAspectType();
+ // if (declaringAspectType.isRawType()) declaringAspectType = declaringAspectType.getGenericType();
+ // if (declaringAspectType.isGenericType()) {
+ //
+ // ResolvedType genericOnType = getWorld().resolve(sig.getDeclaringType()).getGenericType();
+ // ConcreteTypeMunger ctm = munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy(genericOnType));
+ // sig = ctm.getSignature(); // possible sig change when type
+ // }
+ // if (munger.getMunger().hasTypeVariableAliases()) {
+ // ResolvedType genericOnType =
+ // getWorld().resolve(sig.getDeclaringType()).getGenericType();
+ // ConcreteTypeMunger ctm =
+ // munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy(genericOnType));
+ // sig = ctm.getSignature(); // possible sig change when type parameters filled in
+ // }
while (existingMembers.hasNext()) {
-
- ResolvedMember existingMember = (ResolvedMember)existingMembers.next();
+
+ ResolvedMember existingMember = (ResolvedMember) existingMembers.next();
// don't worry about clashing with bridge methods
- if (existingMember.isBridgeMethod()) continue;
- //System.err.println("Comparing munger: "+sig+" with member "+existingMember);
+ if (existingMember.isBridgeMethod())
+ continue;
+ // System.err.println("Comparing munger: "+sig+" with member "+existingMember);
if (conflictingSignature(existingMember, munger.getSignature())) {
- //System.err.println("conflict: existingMember=" + existingMember + " typeMunger=" + munger);
- //System.err.println(munger.getSourceLocation() + ", " + munger.getSignature() + ", " + munger.getSignature().getSourceLocation());
-
+ // System.err.println("conflict: existingMember=" + existingMember + " typeMunger=" + munger);
+ // System.err.println(munger.getSourceLocation() + ", " + munger.getSignature() + ", " +
+ // munger.getSignature().getSourceLocation());
+
if (isVisible(existingMember.getModifiers(), this, munger.getAspectType())) {
int c = compareMemberPrecedence(sig, existingMember);
- //System.err.println(" c: " + c);
+ // System.err.println(" c: " + c);
if (c < 0) {
// existingMember dominates munger
checkLegalOverride(munger.getSignature(), existingMember);
} else if (c > 0) {
// munger dominates existingMember
checkLegalOverride(existingMember, munger.getSignature());
- //interTypeMungers.add(munger);
- //??? might need list of these overridden abstracts
+ // interTypeMungers.add(munger);
+ // ??? might need list of these overridden abstracts
continue;
} else {
- // bridge methods can differ solely in return type.
- // FIXME this whole method seems very hokey - unaware of covariance/varargs/bridging - it
- // could do with a rewrite !
- boolean sameReturnTypes = (existingMember.getReturnType().equals(sig.getReturnType()));
- if (sameReturnTypes) {
- // pr206732 - if the existingMember is due to a previous application of this same ITD (which can
- // happen if this is a binary type being brought in from the aspectpath). The 'better' fix is
- // to recognize it is from the aspectpath at a higher level and dont do this, but that is rather
- // more work.
- boolean isDuplicateOfPreviousITD = false;
- ResolvedType declaringRt = existingMember.getDeclaringType().resolve(world);
- WeaverStateInfo wsi = declaringRt.getWeaverState();
- if (wsi!=null) {
- List mungersAffectingThisType = wsi.getTypeMungers(declaringRt);
- if (mungersAffectingThisType!=null) {
- for (Iterator iterator = mungersAffectingThisType.iterator(); iterator.hasNext() && !isDuplicateOfPreviousITD;) {
- ConcreteTypeMunger ctMunger = (ConcreteTypeMunger) iterator.next();
- // relatively crude check - is the ITD for the same as the existingmember and does it come from the same aspect
- if (ctMunger.getSignature().equals(existingMember) && ctMunger.aspectType.equals(munger.getAspectType())) {
- isDuplicateOfPreviousITD=true;
+ // bridge methods can differ solely in return type.
+ // FIXME this whole method seems very hokey - unaware of covariance/varargs/bridging - it
+ // could do with a rewrite !
+ boolean sameReturnTypes = (existingMember.getReturnType().equals(sig.getReturnType()));
+ if (sameReturnTypes) {
+ // pr206732 - if the existingMember is due to a previous application of this same ITD (which can
+ // happen if this is a binary type being brought in from the aspectpath). The 'better' fix is
+ // to recognize it is from the aspectpath at a higher level and dont do this, but that is rather
+ // more work.
+ boolean isDuplicateOfPreviousITD = false;
+ ResolvedType declaringRt = existingMember.getDeclaringType().resolve(world);
+ WeaverStateInfo wsi = declaringRt.getWeaverState();
+ if (wsi != null) {
+ List mungersAffectingThisType = wsi.getTypeMungers(declaringRt);
+ if (mungersAffectingThisType != null) {
+ for (Iterator iterator = mungersAffectingThisType.iterator(); iterator.hasNext()
+ && !isDuplicateOfPreviousITD;) {
+ ConcreteTypeMunger ctMunger = (ConcreteTypeMunger) iterator.next();
+ // relatively crude check - is the ITD for the same as the existingmember and does it come
+ // from the same aspect
+ if (ctMunger.getSignature().equals(existingMember)
+ && ctMunger.aspectType.equals(munger.getAspectType())) {
+ isDuplicateOfPreviousITD = true;
+ }
}
- }
- }
- }
- if (!isDuplicateOfPreviousITD) {
- getWorld().getMessageHandler().handleMessage(
- MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT,munger.getAspectType().getName(),
- existingMember),
- munger.getSourceLocation())
- );
- }
- }
+ }
+ }
+ if (!isDuplicateOfPreviousITD) {
+ getWorld().getMessageHandler().handleMessage(
+ MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT, munger
+ .getAspectType().getName(), existingMember), munger.getSourceLocation()));
+ }
+ }
}
- } else if (isDuplicateMemberWithinTargetType(existingMember,this,sig)) {
- getWorld().getMessageHandler().handleMessage(
- MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT,munger.getAspectType().getName(),
- existingMember),
- munger.getSourceLocation())
- );
-
+ } else if (isDuplicateMemberWithinTargetType(existingMember, this, sig)) {
+ getWorld().getMessageHandler().handleMessage(
+ MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT, munger.getAspectType()
+ .getName(), existingMember), munger.getSourceLocation()));
+
}
- //return;
+ // return;
}
}
return true;
}
-
+
// we know that the member signature matches, but that the member in the target type is not visible to the aspect.
// this may still be disallowed if it would result in two members within the same declaring type with the same
// signature AND more than one of them is concrete AND they are both visible within the target type.
- private boolean isDuplicateMemberWithinTargetType(ResolvedMember existingMember, ResolvedType targetType,ResolvedMember itdMember) {
- if ( (existingMember.isAbstract() || itdMember.isAbstract())) return false;
- UnresolvedType declaringType = existingMember.getDeclaringType();
- if (!targetType.equals(declaringType)) return false;
- // now have to test that itdMember is visible from targetType
- if (itdMember.isPrivate()) return false;
- if (itdMember.isPublic()) return true;
- // must be in same package to be visible then...
- if (!targetType.getPackageName().equals(itdMember.getDeclaringType().getPackageName())) return false;
-
- // trying to put two members with the same signature into the exact same type..., and both visible in that type.
- return true;
- }
-
+ private boolean isDuplicateMemberWithinTargetType(ResolvedMember existingMember, ResolvedType targetType,
+ ResolvedMember itdMember) {
+ if ((existingMember.isAbstract() || itdMember.isAbstract()))
+ return false;
+ UnresolvedType declaringType = existingMember.getDeclaringType();
+ if (!targetType.equals(declaringType))
+ return false;
+ // now have to test that itdMember is visible from targetType
+ if (itdMember.isPrivate())
+ return false;
+ if (itdMember.isPublic())
+ return true;
+ // must be in same package to be visible then...
+ if (!targetType.getPackageName().equals(itdMember.getDeclaringType().getPackageName()))
+ return false;
+
+ // trying to put two members with the same signature into the exact same type..., and both visible in that type.
+ return true;
+ }
+
/**
- * @return true if the override is legal
- * note: calling showMessage with two locations issues TWO messages, not ONE message
- * with an additional source location.
+ * @return true if the override is legal note: calling showMessage with two locations issues TWO messages, not ONE message with
+ * an additional source location.
*/
public boolean checkLegalOverride(ResolvedMember parent, ResolvedMember child) {
- //System.err.println("check: " + child.getDeclaringType() + " overrides " + parent.getDeclaringType());
+ // System.err.println("check: " + child.getDeclaringType() + " overrides " + parent.getDeclaringType());
if (Modifier.isFinal(parent.getModifiers())) {
- world.showMessage(Message.ERROR,
- WeaverMessages.format(WeaverMessages.CANT_OVERRIDE_FINAL_MEMBER,parent),
- child.getSourceLocation(),null);
+ world.showMessage(Message.ERROR, WeaverMessages.format(WeaverMessages.CANT_OVERRIDE_FINAL_MEMBER, parent), child
+ .getSourceLocation(), null);
return false;
}
-
+
boolean incompatibleReturnTypes = false;
// In 1.5 mode, allow for covariance on return type
- if (world.isInJava5Mode() && parent.getKind()==Member.METHOD) {
-
- // Look at the generic types when doing this comparison
- ResolvedType rtParentReturnType = parent.resolve(world).getGenericReturnType().resolve(world);
- ResolvedType rtChildReturnType = child.resolve(world).getGenericReturnType().resolve(world);
- incompatibleReturnTypes = !rtParentReturnType.isAssignableFrom(rtChildReturnType);
- // For debug, uncomment this bit and we'll repeat the check - stick a breakpoint on the call
-// if (incompatibleReturnTypes) {
-// incompatibleReturnTypes = !rtParentReturnType.isAssignableFrom(rtChildReturnType);
-// }
+ if (world.isInJava5Mode() && parent.getKind() == Member.METHOD) {
+
+ // Look at the generic types when doing this comparison
+ ResolvedType rtParentReturnType = parent.resolve(world).getGenericReturnType().resolve(world);
+ ResolvedType rtChildReturnType = child.resolve(world).getGenericReturnType().resolve(world);
+ incompatibleReturnTypes = !rtParentReturnType.isAssignableFrom(rtChildReturnType);
+ // For debug, uncomment this bit and we'll repeat the check - stick a breakpoint on the call
+ // if (incompatibleReturnTypes) {
+ // incompatibleReturnTypes = !rtParentReturnType.isAssignableFrom(rtChildReturnType);
+ // }
} else {
- incompatibleReturnTypes =!parent.getReturnType().equals(child.getReturnType());
+ incompatibleReturnTypes = !parent.getReturnType().equals(child.getReturnType());
}
-
+
if (incompatibleReturnTypes) {
- world.showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.ITD_RETURN_TYPE_MISMATCH,parent,child),
- child.getSourceLocation(), parent.getSourceLocation());
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_RETURN_TYPE_MISMATCH, parent, child), child
+ .getSourceLocation(), parent.getSourceLocation());
return false;
- }
+ }
if (parent.getKind() == Member.POINTCUT) {
UnresolvedType[] pTypes = parent.getParameterTypes();
UnresolvedType[] cTypes = child.getParameterTypes();
if (!Arrays.equals(pTypes, cTypes)) {
- world.showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.ITD_PARAM_TYPE_MISMATCH,parent,child),
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_PARAM_TYPE_MISMATCH, parent, child),
child.getSourceLocation(), parent.getSourceLocation());
return false;
}
- }
- //System.err.println("check: " + child.getModifiers() + " more visible " + parent.getModifiers());
+ }
+ // System.err.println("check: " + child.getModifiers() + " more visible " + parent.getModifiers());
if (isMoreVisible(parent.getModifiers(), child.getModifiers())) {
- world.showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.ITD_VISIBILITY_REDUCTION,parent,child),
- child.getSourceLocation(), parent.getSourceLocation());
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_VISIBILITY_REDUCTION, parent, child), child
+ .getSourceLocation(), parent.getSourceLocation());
return false;
}
-
+
// check declared exceptions
ResolvedType[] childExceptions = world.resolve(child.getExceptions());
ResolvedType[] parentExceptions = world.resolve(parent.getExceptions());
ResolvedType runtimeException = world.resolve("java.lang.RuntimeException");
ResolvedType error = world.resolve("java.lang.Error");
-
- outer:
- for (int i = 0, leni = childExceptions.length; i < leni; i++) {
- //System.err.println("checking: " + childExceptions[i]);
- if (runtimeException.isAssignableFrom(childExceptions[i])) continue;
- if (error.isAssignableFrom(childExceptions[i])) continue;
-
+
+ outer: for (int i = 0, leni = childExceptions.length; i < leni; i++) {
+ // System.err.println("checking: " + childExceptions[i]);
+ if (runtimeException.isAssignableFrom(childExceptions[i]))
+ continue;
+ if (error.isAssignableFrom(childExceptions[i]))
+ continue;
+
for (int j = 0, lenj = parentExceptions.length; j < lenj; j++) {
- if (parentExceptions[j].isAssignableFrom(childExceptions[i])) continue outer;
+ if (parentExceptions[j].isAssignableFrom(childExceptions[i]))
+ continue outer;
}
-
+
// this message is now better handled my MethodVerifier in JDT core.
-// world.showMessage(IMessage.ERROR,
-// WeaverMessages.format(WeaverMessages.ITD_DOESNT_THROW,childExceptions[i].getName()),
-// child.getSourceLocation(), null);
-
+ // world.showMessage(IMessage.ERROR,
+ // WeaverMessages.format(WeaverMessages.ITD_DOESNT_THROW,childExceptions[i].getName()),
+ // child.getSourceLocation(), null);
+
return false;
}
if (parent.isStatic() && !child.isStatic()) {
- world.showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.ITD_OVERRIDDEN_STATIC,child,parent),
- child.getSourceLocation(),null);
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_OVERRIDDEN_STATIC, child, parent), child
+ .getSourceLocation(), null);
return false;
} else if (child.isStatic() && !parent.isStatic()) {
- world.showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.ITD_OVERIDDING_STATIC,child,parent),
- child.getSourceLocation(),null);
+ world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_OVERIDDING_STATIC, child, parent), child
+ .getSourceLocation(), null);
return false;
}
return true;
-
+
}
-
+
private int compareMemberPrecedence(ResolvedMember m1, ResolvedMember m2) {
- //if (!m1.getReturnType().equals(m2.getReturnType())) return 0;
-
+ // if (!m1.getReturnType().equals(m2.getReturnType())) return 0;
+
// need to allow for the special case of 'clone' - which is like abstract but is
- // not marked abstract. The code below this next line seems to make assumptions
+ // not marked abstract. The code below this next line seems to make assumptions
// about what will have gotten through the compiler based on the normal
- // java rules. clone goes against these...
- if (m2.isProtected() && m2.getName().charAt(0)=='c') {
+ // java rules. clone goes against these...
+ if (m2.isProtected() && m2.getName().charAt(0) == 'c') {
UnresolvedType declaring = m2.getDeclaringType();
- if (declaring!=null) {
- if (declaring.getName().equals("java.lang.Object") && m2.getName().equals("clone")) return +1;
+ if (declaring != null) {
+ if (declaring.getName().equals("java.lang.Object") && m2.getName().equals("clone"))
+ return +1;
}
}
- if (Modifier.isAbstract(m1.getModifiers())) return -1;
- if (Modifier.isAbstract(m2.getModifiers())) return +1;
-
- if (m1.getDeclaringType().equals(m2.getDeclaringType())) return 0;
-
+ if (Modifier.isAbstract(m1.getModifiers()))
+ return -1;
+ if (Modifier.isAbstract(m2.getModifiers()))
+ return +1;
+
+ if (m1.getDeclaringType().equals(m2.getDeclaringType()))
+ return 0;
+
ResolvedType t1 = m1.getDeclaringType().resolve(world);
ResolvedType t2 = m2.getDeclaringType().resolve(world);
if (t1.isAssignableFrom(t2)) {
}
return 0;
}
-
public static boolean isMoreVisible(int m1, int m2) {
- if (Modifier.isPrivate(m1)) return false;
- if (isPackage(m1)) return Modifier.isPrivate(m2);
- if (Modifier.isProtected(m1)) return /* private package */ (Modifier.isPrivate(m2) || isPackage(m2));
- if (Modifier.isPublic(m1)) return /* private package protected */ ! Modifier.isPublic(m2);
+ if (Modifier.isPrivate(m1))
+ return false;
+ if (isPackage(m1))
+ return Modifier.isPrivate(m2);
+ if (Modifier.isProtected(m1))
+ return /* private package */(Modifier.isPrivate(m2) || isPackage(m2));
+ if (Modifier.isPublic(m1))
+ return /* private package protected */!Modifier.isPublic(m2);
throw new RuntimeException("bad modifier: " + m1);
}
return (0 == (i & (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED)));
}
- private void interTypeConflictError(
- ConcreteTypeMunger m1,
- ConcreteTypeMunger m2) {
- //XXX this works only if we ignore separate compilation issues
- //XXX dual errors possible if (this instanceof BcelObjectType) return;
-
- //System.err.println("conflict at " + m2.getSourceLocation());
- getWorld().showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.ITD_CONFLICT,m1.getAspectType().getName(),
- m2.getSignature(),m2.getAspectType().getName()),
- m2.getSourceLocation(), getSourceLocation());
- }
-
-
+ private void interTypeConflictError(ConcreteTypeMunger m1, ConcreteTypeMunger m2) {
+ // XXX this works only if we ignore separate compilation issues
+ // XXX dual errors possible if (this instanceof BcelObjectType) return;
+
+ // System.err.println("conflict at " + m2.getSourceLocation());
+ getWorld().showMessage(
+ IMessage.ERROR,
+ WeaverMessages.format(WeaverMessages.ITD_CONFLICT, m1.getAspectType().getName(), m2.getSignature(), m2
+ .getAspectType().getName()), m2.getSourceLocation(), getSourceLocation());
+ }
+
public ResolvedMember lookupSyntheticMember(Member member) {
- //??? horribly inefficient
- //for (Iterator i =
- //System.err.println("lookup " + member + " in " + interTypeMungers);
- for (Iterator i = interTypeMungers.iterator(); i.hasNext(); ) {
- ConcreteTypeMunger m = (ConcreteTypeMunger)i.next();
+ // ??? horribly inefficient
+ // for (Iterator i =
+ // System.err.println("lookup " + member + " in " + interTypeMungers);
+ for (Iterator i = interTypeMungers.iterator(); i.hasNext();) {
+ ConcreteTypeMunger m = (ConcreteTypeMunger) i.next();
ResolvedMember ret = m.getMatchingSyntheticMember(member);
if (ret != null) {
- //System.err.println(" found: " + ret);
+ // System.err.println(" found: " + ret);
return ret;
}
}
-
+
// Handling members for the new array join point
if (world.isJoinpointArrayConstructionEnabled() && this.isArray()) {
- if (member.getKind()==Member.CONSTRUCTOR) {
- ResolvedMemberImpl ret =
- new ResolvedMemberImpl(Member.CONSTRUCTOR,this,Modifier.PUBLIC,
- ResolvedType.VOID,"<init>",world.resolve(member.getParameterTypes()));
+ if (member.getKind() == Member.CONSTRUCTOR) {
+ ResolvedMemberImpl ret = new ResolvedMemberImpl(Member.CONSTRUCTOR, this, Modifier.PUBLIC, ResolvedType.VOID,
+ "<init>", world.resolve(member.getParameterTypes()));
return ret;
}
}
-
-// if (this.getSuperclass() != ResolvedType.OBJECT && this.getSuperclass() != null) {
-// return getSuperclass().lookupSyntheticMember(member);
-// }
-
+
+ // if (this.getSuperclass() != ResolvedType.OBJECT && this.getSuperclass() != null) {
+ // return getSuperclass().lookupSyntheticMember(member);
+ // }
+
return null;
}
public void clearInterTypeMungers() {
- if (isRawType()) getGenericType().clearInterTypeMungers();
+ if (isRawType())
+ getGenericType().clearInterTypeMungers();
interTypeMungers = new ArrayList();
}
-
public boolean isTopmostImplementor(ResolvedType interfaceType) {
- if (isInterface()) return false;
- if (!interfaceType.isAssignableFrom(this,true)) return false;
+ if (isInterface())
+ return false;
+ if (!interfaceType.isAssignableFrom(this, true))
+ return false;
// check that I'm truly the topmost implementor
- if (this.getSuperclass().isMissing()) return true; // we don't know anything about supertype, and it can't be exposed to weaver
- if (interfaceType.isAssignableFrom(this.getSuperclass(),true)) {
+ if (this.getSuperclass().isMissing())
+ return true; // we don't know anything about supertype, and it can't be exposed to weaver
+ if (interfaceType.isAssignableFrom(this.getSuperclass(), true)) {
return false;
}
return true;
}
-
+
public ResolvedType getTopmostImplementor(ResolvedType interfaceType) {
- if (isInterface()) return null;
- if (!interfaceType.isAssignableFrom(this)) return null;
+ if (isInterface())
+ return null;
+ if (!interfaceType.isAssignableFrom(this))
+ return null;
// Check if my super class is an implementor?
- ResolvedType higherType = this.getSuperclass().getTopmostImplementor(interfaceType);
- if (higherType!=null) return higherType;
+ ResolvedType higherType = this.getSuperclass().getTopmostImplementor(interfaceType);
+ if (higherType != null)
+ return higherType;
return this;
}
-
+
public List getExposedPointcuts() {
List ret = new ArrayList();
- if (getSuperclass() != null) ret.addAll(getSuperclass().getExposedPointcuts());
-
- for (Iterator i = Arrays.asList(getDeclaredInterfaces()).iterator(); i.hasNext(); ) {
- ResolvedType t = (ResolvedType)i.next();
+ if (getSuperclass() != null)
+ ret.addAll(getSuperclass().getExposedPointcuts());
+
+ for (Iterator i = Arrays.asList(getDeclaredInterfaces()).iterator(); i.hasNext();) {
+ ResolvedType t = (ResolvedType) i.next();
addPointcutsResolvingConflicts(ret, Arrays.asList(t.getDeclaredPointcuts()), false);
}
addPointcutsResolvingConflicts(ret, Arrays.asList(getDeclaredPointcuts()), true);
- for (Iterator i = ret.iterator(); i.hasNext(); ) {
- ResolvedPointcutDefinition inherited = (ResolvedPointcutDefinition)i.next();
-// System.err.println("looking at: " + inherited + " in " + this);
-// System.err.println(" " + inherited.isAbstract() + " in " + this.isAbstract());
+ for (Iterator i = ret.iterator(); i.hasNext();) {
+ ResolvedPointcutDefinition inherited = (ResolvedPointcutDefinition) i.next();
+ // System.err.println("looking at: " + inherited + " in " + this);
+ // System.err.println(" " + inherited.isAbstract() + " in " + this.isAbstract());
if (inherited.isAbstract()) {
if (!this.isAbstract()) {
getWorld().showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.POINCUT_NOT_CONCRETE,inherited,this.getName()),
+ WeaverMessages.format(WeaverMessages.POINCUT_NOT_CONCRETE, inherited, this.getName()),
inherited.getSourceLocation(), this.getSourceLocation());
}
}
- }
-
-
+ }
+
return ret;
}
-
+
private void addPointcutsResolvingConflicts(List acc, List added, boolean isOverriding) {
for (Iterator i = added.iterator(); i.hasNext();) {
- ResolvedPointcutDefinition toAdd =
- (ResolvedPointcutDefinition) i.next();
- //System.err.println("adding: " + toAdd);
+ ResolvedPointcutDefinition toAdd = (ResolvedPointcutDefinition) i.next();
+ // System.err.println("adding: " + toAdd);
for (Iterator j = acc.iterator(); j.hasNext();) {
- ResolvedPointcutDefinition existing =
- (ResolvedPointcutDefinition) j.next();
- if (existing == toAdd) continue;
- if (!isVisible(existing.getModifiers(),
- existing.getDeclaringType().resolve(getWorld()),
- this)) {
+ ResolvedPointcutDefinition existing = (ResolvedPointcutDefinition) j.next();
+ if (existing == toAdd)
+ continue;
+ if (!isVisible(existing.getModifiers(), existing.getDeclaringType().resolve(getWorld()), this)) {
// if they intended to override it but it is not visible, give them a nicer message
- if (existing.isAbstract() && conflictingSignature(existing,toAdd)) {
+ if (existing.isAbstract() && conflictingSignature(existing, toAdd)) {
getWorld().showMessage(
IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.POINTCUT_NOT_VISIBLE,
- existing.getDeclaringType().getName() + "." + existing.getName()+"()", this.getName()),
- toAdd.getSourceLocation(),null);
+ WeaverMessages.format(WeaverMessages.POINTCUT_NOT_VISIBLE, existing.getDeclaringType().getName()
+ + "." + existing.getName() + "()", this.getName()), toAdd.getSourceLocation(), null);
j.remove();
}
continue;
j.remove();
} else {
getWorld().showMessage(
- IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.CONFLICTING_INHERITED_POINTCUTS,this.getName() + toAdd.getSignature()),
- existing.getSourceLocation(),
- toAdd.getSourceLocation());
+ IMessage.ERROR,
+ WeaverMessages.format(WeaverMessages.CONFLICTING_INHERITED_POINTCUTS, this.getName()
+ + toAdd.getSignature()), existing.getSourceLocation(), toAdd.getSourceLocation());
j.remove();
}
}
acc.add(toAdd);
}
}
-
- public ISourceLocation getSourceLocation() {
- return null;
- }
- public boolean isExposedToWeaver() {
- return false;
- }
+ public ISourceLocation getSourceLocation() {
+ return null;
+ }
+
+ public boolean isExposedToWeaver() {
+ return false;
+ }
public WeaverStateInfo getWeaverState() {
return null;
}
-
+
/**
* Overridden by ReferenceType to return a sensible answer for parameterized and raw types.
- *
+ *
* @return
*/
public ResolvedType getGenericType() {
if (!(isParameterizedType() || isRawType()))
- throw new BCException("The type "+getBaseName()+" is not parameterized or raw - it has no generic type");
+ throw new BCException("The type " + getBaseName() + " is not parameterized or raw - it has no generic type");
return null;
}
-
+
/**
* overriden by ReferenceType to return the gsig for a generic type
+ *
* @return
*/
public String getGenericSignature() {
return "";
}
-
-
+
public ResolvedType parameterizedWith(UnresolvedType[] typeParameters) {
- if (!(isGenericType() || isParameterizedType())) return this;
+ if (!(isGenericType() || isParameterizedType()))
+ return this;
return TypeFactory.createParameterizedType(this.getGenericType(), typeParameters, getWorld());
}
-
+
/**
- * Iff I am a parameterized type, and any of my parameters are type variable
- * references, return a version with those type parameters replaced in accordance
- * with the passed bindings.
+ * Iff I am a parameterized type, and any of my parameters are type variable references, return a version with those type
+ * parameters replaced in accordance with the passed bindings.
*/
public UnresolvedType parameterize(Map typeBindings) {
- if (!isParameterizedType()) return this;//throw new IllegalStateException("Can't parameterize a type that is not a parameterized type");
- boolean workToDo = false;
- for (int i = 0; i < typeParameters.length; i++) {
- if (typeParameters[i].isTypeVariableReference() ||
- (typeParameters[i] instanceof BoundedReferenceType)) {
+ if (!isParameterizedType())
+ return this;// throw new IllegalStateException("Can't parameterize a type that is not a parameterized type");
+ boolean workToDo = false;
+ for (int i = 0; i < typeParameters.length; i++) {
+ if (typeParameters[i].isTypeVariableReference() || (typeParameters[i] instanceof BoundedReferenceType)) {
workToDo = true;
}
}
- if (!workToDo) {
- return this;
- } else {
- UnresolvedType[] newTypeParams = new UnresolvedType[typeParameters.length];
- for (int i = 0; i < newTypeParams.length; i++) {
+ if (!workToDo) {
+ return this;
+ } else {
+ UnresolvedType[] newTypeParams = new UnresolvedType[typeParameters.length];
+ for (int i = 0; i < newTypeParams.length; i++) {
newTypeParams[i] = typeParameters[i];
if (newTypeParams[i].isTypeVariableReference()) {
TypeVariableReferenceType tvrt = (TypeVariableReferenceType) newTypeParams[i];
UnresolvedType binding = (UnresolvedType) typeBindings.get(tvrt.getTypeVariable().getName());
- if (binding != null) newTypeParams[i] = binding;
+ if (binding != null)
+ newTypeParams[i] = binding;
} else if (newTypeParams[i] instanceof BoundedReferenceType) {
- BoundedReferenceType brType = (BoundedReferenceType)newTypeParams[i];
+ BoundedReferenceType brType = (BoundedReferenceType) newTypeParams[i];
newTypeParams[i] = brType.parameterize(typeBindings);
-// brType.parameterize(typeBindings)
+ // brType.parameterize(typeBindings)
}
}
- return TypeFactory.createParameterizedType(getGenericType(), newTypeParams, getWorld());
- }
- }
-
+ return TypeFactory.createParameterizedType(getGenericType(), newTypeParams, getWorld());
+ }
+ }
+
public boolean hasParameterizedSuperType() {
getParameterizedSuperTypes();
return parameterizedSuperTypes.length > 0;
}
-
+
public boolean hasGenericSuperType() {
ResolvedType[] superTypes = getDeclaredInterfaces();
for (int i = 0; i < superTypes.length; i++) {
- if (superTypes[i].isGenericType()) return true;
+ if (superTypes[i].isGenericType())
+ return true;
}
return false;
}
-
+
private ResolvedType[] parameterizedSuperTypes = null;
+
/**
* Similar to the above method, but accumulates the super types
- *
+ *
* @return
*/
public ResolvedType[] getParameterizedSuperTypes() {
- if (parameterizedSuperTypes != null) return parameterizedSuperTypes;
+ if (parameterizedSuperTypes != null)
+ return parameterizedSuperTypes;
List accumulatedTypes = new ArrayList();
- accumulateParameterizedSuperTypes(this,accumulatedTypes);
+ accumulateParameterizedSuperTypes(this, accumulatedTypes);
ResolvedType[] ret = new ResolvedType[accumulatedTypes.size()];
parameterizedSuperTypes = (ResolvedType[]) accumulatedTypes.toArray(ret);
return parameterizedSuperTypes;
}
-
+
private void accumulateParameterizedSuperTypes(ResolvedType forType, List parameterizedTypeList) {
if (forType.isParameterizedType()) {
parameterizedTypeList.add(forType);
* Types may have pointcuts just as they have methods and fields.
*/
public ResolvedPointcutDefinition findPointcut(String name, World world) {
- throw new UnsupportedOperationException("Not yet implemenented");
+ throw new UnsupportedOperationException("Not yet implemenented");
}
-
+
/**
* @return true if assignable to java.lang.Exception
*/
public boolean isException() {
return (world.getCoreType(UnresolvedType.JAVA_LANG_EXCEPTION).isAssignableFrom(this));
}
-
+
/**
* @return true if it is an exception and it is a checked one, false otherwise.
*/
public boolean isCheckedException() {
- if (!isException()) return false;
- if (world.getCoreType(UnresolvedType.RUNTIME_EXCEPTION).isAssignableFrom(this)) return false;
+ if (!isException())
+ return false;
+ if (world.getCoreType(UnresolvedType.RUNTIME_EXCEPTION).isAssignableFrom(this))
+ return false;
return true;
}
/**
- * Determines if variables of this type could be assigned values of another
- * with lots of help.
- * java.lang.Object is convertable from all types.
- * A primitive type is convertable from X iff it's assignable from X.
- * A reference type is convertable from X iff it's coerceable from X.
- * In other words, X isConvertableFrom Y iff the compiler thinks that _some_ value of Y
- * could be assignable to a variable of type X without loss of precision.
+ * Determines if variables of this type could be assigned values of another with lots of help. java.lang.Object is convertable
+ * from all types. A primitive type is convertable from X iff it's assignable from X. A reference type is convertable from X iff
+ * it's coerceable from X. In other words, X isConvertableFrom Y iff the compiler thinks that _some_ value of Y could be
+ * assignable to a variable of type X without loss of precision.
*
* @param other the other type
* @param world the {@link World} in which the possible assignment should be checked.
* @return true iff variables of this type could be assigned values of other with possible conversion
*/
- public final boolean isConvertableFrom(ResolvedType other) {
-
-// // version from TypeX
-// if (this.equals(OBJECT)) return true;
-// if (this.isPrimitiveType() || other.isPrimitiveType()) return this.isAssignableFrom(other);
-// return this.isCoerceableFrom(other);
-//
-
- // version from ResolvedTypeX
- if (this.equals(OBJECT)) return true;
- if (world.isInJava5Mode()) {
- if (this.isPrimitiveType()^other.isPrimitiveType()) { // If one is primitive and the other isnt
- if (validBoxing.contains(this.getSignature()+other.getSignature())) return true;
- }
- }
- if (this.isPrimitiveType() || other.isPrimitiveType()) return this.isAssignableFrom(other);
- return this.isCoerceableFrom(other);
- }
+ public final boolean isConvertableFrom(ResolvedType other) {
+
+ // // version from TypeX
+ // if (this.equals(OBJECT)) return true;
+ // if (this.isPrimitiveType() || other.isPrimitiveType()) return this.isAssignableFrom(other);
+ // return this.isCoerceableFrom(other);
+ //
+
+ // version from ResolvedTypeX
+ if (this.equals(OBJECT))
+ return true;
+ if (world.isInJava5Mode()) {
+ if (this.isPrimitiveType() ^ other.isPrimitiveType()) { // If one is primitive and the other isnt
+ if (validBoxing.contains(this.getSignature() + other.getSignature()))
+ return true;
+ }
+ }
+ if (this.isPrimitiveType() || other.isPrimitiveType())
+ return this.isAssignableFrom(other);
+ return this.isCoerceableFrom(other);
+ }
/**
- * Determines if the variables of this type could be assigned values
- * of another type without casting. This still allows for assignment conversion
- * as per JLS 2ed 5.2. For object types, this means supertypeOrEqual(THIS, OTHER).
+ * Determines if the variables of this type could be assigned values of another type without casting. This still allows for
+ * assignment conversion as per JLS 2ed 5.2. For object types, this means supertypeOrEqual(THIS, OTHER).
*
* @param other the other type
* @param world the {@link World} in which the possible assignment should be checked.
* @return true iff variables of this type could be assigned values of other without casting
- * @throws NullPointerException if other is null
+ * @throws NullPointerException if other is null
*/
public abstract boolean isAssignableFrom(ResolvedType other);
-
+
public abstract boolean isAssignableFrom(ResolvedType other, boolean allowMissing);
/**
- * Determines if values of another type could possibly be cast to
- * this type. The rules followed are from JLS 2ed 5.5, "Casting Conversion".
- * <p/>
- * <p> This method should be commutative, i.e., for all UnresolvedType a, b and all World w:
- * <p/>
- * <blockquote><pre>
- * a.isCoerceableFrom(b, w) == b.isCoerceableFrom(a, w)
- * </pre></blockquote>
- *
+ * Determines if values of another type could possibly be cast to this type. The rules followed are from JLS 2ed 5.5,
+ * "Casting Conversion". <p/>
+ * <p>
+ * This method should be commutative, i.e., for all UnresolvedType a, b and all World w: <p/> <blockquote>
+ *
+ * <pre>
+ * a.isCoerceableFrom(b, w) == b.isCoerceableFrom(a, w)
+ * </pre>
+ *
+ * </blockquote>
+ *
* @param other the other type
* @param world the {@link World} in which the possible coersion should be checked.
- * @return true iff values of other could possibly be cast to this type.
- * @throws NullPointerException if other is null.
+ * @return true iff values of other could possibly be cast to this type.
+ * @throws NullPointerException if other is null.
*/
public abstract boolean isCoerceableFrom(ResolvedType other);
-
+
public boolean needsNoConversionFrom(ResolvedType o) {
- return isAssignableFrom(o);
+ return isAssignableFrom(o);
}
-
+
public String getSignatureForAttribute() {
- return signature; // Assume if this is being called that it is for a simple type (eg. void, int, etc)
+ return signature; // Assume if this is being called that it is for a simple type (eg. void, int, etc)
}
-
+
private FuzzyBoolean parameterizedWithTypeVariable = FuzzyBoolean.MAYBE;
-
+
/**
- * return true if the parameterization of this type includes a member type variable. Member
- * type variables occur in generic methods/ctors.
+ * return true if the parameterization of this type includes a member type variable. Member type variables occur in generic
+ * methods/ctors.
*/
public boolean isParameterizedWithTypeVariable() {
// MAYBE means we haven't worked it out yet...
- if (parameterizedWithTypeVariable==FuzzyBoolean.MAYBE) {
-
+ if (parameterizedWithTypeVariable == FuzzyBoolean.MAYBE) {
+
// if there are no type parameters then we cant be...
- if (typeParameters==null || typeParameters.length==0) {
+ if (typeParameters == null || typeParameters.length == 0) {
parameterizedWithTypeVariable = FuzzyBoolean.NO;
return false;
}
-
+
for (int i = 0; i < typeParameters.length; i++) {
- ResolvedType aType = (ResolvedType)typeParameters[i];
- if (aType.isTypeVariableReference()
- // Changed according to the problems covered in bug 222648
- // Don't care what kind of type variable - the fact that there is one
- // at all means we can't risk caching it against we get confused later
- // by another variation of the parameterization that just happens to
- // use the same type variable name
-
- // assume the worst - if its definetly not a type declared one, it could be anything
- // && ((TypeVariableReference)aType).getTypeVariable().getDeclaringElementKind()!=TypeVariable.TYPE
- ) {
+ ResolvedType aType = (ResolvedType) typeParameters[i];
+ if (aType.isTypeVariableReference()
+ // Changed according to the problems covered in bug 222648
+ // Don't care what kind of type variable - the fact that there is one
+ // at all means we can't risk caching it against we get confused later
+ // by another variation of the parameterization that just happens to
+ // use the same type variable name
+
+ // assume the worst - if its definetly not a type declared one, it could be anything
+ // && ((TypeVariableReference)aType).getTypeVariable().getDeclaringElementKind()!=TypeVariable.TYPE
+ ) {
parameterizedWithTypeVariable = FuzzyBoolean.YES;
return true;
}
}
}
if (aType.isGenericWildcard()) {
- BoundedReferenceType boundedRT = (BoundedReferenceType) aType;
+ BoundedReferenceType boundedRT = (BoundedReferenceType) aType;
if (boundedRT.isExtends()) {
boolean b = false;
UnresolvedType upperBound = boundedRT.getUpperBound();
if (upperBound.isParameterizedType()) {
- b = ((ResolvedType)upperBound).isParameterizedWithTypeVariable();
- } else if (upperBound.isTypeVariableReference() && ((TypeVariableReference)upperBound).getTypeVariable().getDeclaringElementKind()==TypeVariable.METHOD) {
+ b = ((ResolvedType) upperBound).isParameterizedWithTypeVariable();
+ } else if (upperBound.isTypeVariableReference()
+ && ((TypeVariableReference) upperBound).getTypeVariable().getDeclaringElementKind() == TypeVariable.METHOD) {
b = true;
}
if (b) {
boolean b = false;
UnresolvedType lowerBound = boundedRT.getLowerBound();
if (lowerBound.isParameterizedType()) {
- b = ((ResolvedType)lowerBound).isParameterizedWithTypeVariable();
- } else if (lowerBound.isTypeVariableReference() && ((TypeVariableReference)lowerBound).getTypeVariable().getDeclaringElementKind()==TypeVariable.METHOD) {
+ b = ((ResolvedType) lowerBound).isParameterizedWithTypeVariable();
+ } else if (lowerBound.isTypeVariableReference()
+ && ((TypeVariableReference) lowerBound).getTypeVariable().getDeclaringElementKind() == TypeVariable.METHOD) {
b = true;
}
if (b) {
}
}
}
- parameterizedWithTypeVariable=FuzzyBoolean.NO;
+ parameterizedWithTypeVariable = FuzzyBoolean.NO;
}
return parameterizedWithTypeVariable.alwaysTrue();
}
protected boolean ajMembersNeedParameterization() {
- if (isParameterizedType()) return true;
- if (getSuperclass() != null) return getSuperclass().ajMembersNeedParameterization();
+ if (isParameterizedType())
+ return true;
+ if (getSuperclass() != null)
+ return getSuperclass().ajMembersNeedParameterization();
return false;
}
Map myMap = getMemberParameterizationMap();
if (myMap.isEmpty()) {
// might extend a parameterized aspect that we also need to consider...
- if (getSuperclass() != null) return getSuperclass().getAjMemberParameterizationMap();
+ if (getSuperclass() != null)
+ return getSuperclass().getAjMemberParameterizationMap();
}
return myMap;
}
-
+
public void setBinaryPath(String binaryPath) {
this.binaryPath = binaryPath;
}
/**
- * Returns the path to the jar or class file from which this
- * binary aspect came or null if not a binary aspect
+ * Returns the path to the jar or class file from which this binary aspect came or null if not a binary aspect
*/
public String getBinaryPath() {
return binaryPath;
}
-
}
* Alexandre Vasseur support for @AJ aspects
* ******************************************************************/
-
package org.aspectj.weaver.bcel;
import java.lang.reflect.Modifier;
import org.aspectj.weaver.WeaverMessages;
import org.aspectj.weaver.World;
import org.aspectj.weaver.ast.Var;
+import org.aspectj.weaver.patterns.AbstractPatternNodeVisitor;
import org.aspectj.weaver.patterns.AndPointcut;
-import org.aspectj.weaver.patterns.IdentityPointcutVisitor;
import org.aspectj.weaver.patterns.NotPointcut;
import org.aspectj.weaver.patterns.OrPointcut;
import org.aspectj.weaver.patterns.ThisOrTargetPointcut;
-
/*
* Some fun implementation stuff:
*
*/
public class BcelShadow extends Shadow {
-
- private ShadowRange range;
- private final BcelWorld world;
- private final LazyMethodGen enclosingMethod;
-
+
+ private ShadowRange range;
+ private final BcelWorld world;
+ private final LazyMethodGen enclosingMethod;
+
// SECRETAPI - for testing, this will tell us if the optimization succeeded *on the last shadow processed*
public static boolean appliedLazyTjpOptimization;
-
- // Some instructions have a target type that will vary
- // from the signature (pr109728) (1.4 declaring type issue)
- private String actualInstructionTargetType;
+
+ // Some instructions have a target type that will vary
+ // from the signature (pr109728) (1.4 declaring type issue)
+ private String actualInstructionTargetType;
/**
- * This generates an unassociated shadow, rooted in a particular method but not rooted
- * to any particular point in the code. It should be given to a rooted ShadowRange
- * in the {@link ShadowRange#associateWithShadow(BcelShadow)} method.
+ * This generates an unassociated shadow, rooted in a particular method but not rooted to any particular point in the code. It
+ * should be given to a rooted ShadowRange in the {@link ShadowRange#associateWithShadow(BcelShadow)} method.
*/
public BcelShadow(BcelWorld world, Kind kind, Member signature, LazyMethodGen enclosingMethod, BcelShadow enclosingShadow) {
super(kind, signature, enclosingShadow);
public BcelShadow copyInto(LazyMethodGen recipient, BcelShadow enclosing) {
BcelShadow s = new BcelShadow(world, getKind(), getSignature(), recipient, enclosing);
- if (mungers.size()>0) {
+ if (mungers.size() > 0) {
List src = mungers;
- if (s.mungers==Collections.EMPTY_LIST) s.mungers = new ArrayList();
+ if (s.mungers == Collections.EMPTY_LIST)
+ s.mungers = new ArrayList();
List dest = s.mungers;
-
- for (Iterator i = src.iterator(); i.hasNext(); ) {
+
+ for (Iterator i = src.iterator(); i.hasNext();) {
dest.add(i.next());
}
}
return s;
}
- // ---- overridden behaviour
+ // ---- overridden behaviour
public World getIWorld() {
return world;
int depth = 1;
InstructionHandle ih = range.getStart();
- // Go back from where we are looking for 'NEW' that takes us to a stack depth of 0. INVOKESPECIAL <init>
+ // Go back from where we are looking for 'NEW' that takes us to a stack depth of 0. INVOKESPECIAL <init>
while (true) {
Instruction inst = ih.getInstruction();
- if (inst.opcode==Constants.INVOKESPECIAL
- && ((InvokeInstruction) inst).getName(cpg).equals("<init>")) {
+ if (inst.opcode == Constants.INVOKESPECIAL && ((InvokeInstruction) inst).getName(cpg).equals("<init>")) {
depth++;
- } else if (inst.opcode==Constants.NEW) {
+ } else if (inst.opcode == Constants.NEW) {
depth--;
- if (depth == 0) break;
- } else if (inst.opcode==Constants.DUP_X2) {
+ if (depth == 0)
+ break;
+ } else if (inst.opcode == Constants.DUP_X2) {
// This code seen in the wild (by Brad):
-// 40: new #12; //class java/lang/StringBuffer
-// STACK: STRINGBUFFER
-// 43: dup
-// STACK: STRINGBUFFER/STRINGBUFFER
-// 44: aload_0
-// STACK: STRINGBUFFER/STRINGBUFFER/THIS
-// 45: dup_x2
-// STACK: THIS/STRINGBUFFER/STRINGBUFFER/THIS
-// 46: getfield #36; //Field value:Ljava/lang/String;
-// STACK: THIS/STRINGBUFFER/STRINGBUFFER/STRING<value>
-// 49: invokestatic #37; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
-// STACK: THIS/STRINGBUFFER/STRINGBUFFER/STRING
-// 52: invokespecial #19; //Method java/lang/StringBuffer."<init>":(Ljava/lang/String;)V
-// STACK: THIS/STRINGBUFFER
-// 55: aload_1
-// STACK: THIS/STRINGBUFFER/LOCAL1
-// 56: invokevirtual #22; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
-// STACK: THIS/STRINGBUFFER
-// 59: invokevirtual #34; //Method java/lang/StringBuffer.toString:()Ljava/lang/String;
-// STACK: THIS/STRING
-// 62: putfield #36; //Field value:Ljava/lang/String;
-// STACK: <empty>
-// 65: return
-
+ // 40: new #12; //class java/lang/StringBuffer
+ // STACK: STRINGBUFFER
+ // 43: dup
+ // STACK: STRINGBUFFER/STRINGBUFFER
+ // 44: aload_0
+ // STACK: STRINGBUFFER/STRINGBUFFER/THIS
+ // 45: dup_x2
+ // STACK: THIS/STRINGBUFFER/STRINGBUFFER/THIS
+ // 46: getfield #36; //Field value:Ljava/lang/String;
+ // STACK: THIS/STRINGBUFFER/STRINGBUFFER/STRING<value>
+ // 49: invokestatic #37; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
+ // STACK: THIS/STRINGBUFFER/STRINGBUFFER/STRING
+ // 52: invokespecial #19; //Method java/lang/StringBuffer."<init>":(Ljava/lang/String;)V
+ // STACK: THIS/STRINGBUFFER
+ // 55: aload_1
+ // STACK: THIS/STRINGBUFFER/LOCAL1
+ // 56: invokevirtual #22; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
+ // STACK: THIS/STRINGBUFFER
+ // 59: invokevirtual #34; //Method java/lang/StringBuffer.toString:()Ljava/lang/String;
+ // STACK: THIS/STRING
+ // 62: putfield #36; //Field value:Ljava/lang/String;
+ // STACK: <empty>
+ // 65: return
+
// if we attempt to match on the ctor call to StringBuffer.<init> then we get into trouble.
// if we simply delete the new/dup pair without fixing up the dup_x2 then the dup_x2 will fail due to there
- // not being 3 elements on the stack for it to work with. The fix *in this situation* is to change it to
+ // not being 3 elements on the stack for it to work with. The fix *in this situation* is to change it to
// a simple 'dup'
-
+
// this fix is *not* very clean - but a general purpose decent solution will take much longer and this
// bytecode sequence has only been seen once in the wild.
ih.setInstruction(InstructionConstants.DUP);
}
ih = ih.getPrev();
}
- // now IH points to the NEW. We're followed by the DUP, and that is followed
- // by the actual instruction we care about.
+ // now IH points to the NEW. We're followed by the DUP, and that is followed
+ // by the actual instruction we care about.
InstructionHandle newHandle = ih;
InstructionHandle endHandle = newHandle.getNext();
InstructionHandle nextHandle;
- if (endHandle.getInstruction().opcode==Constants.DUP) {
- nextHandle = endHandle.getNext();
+ if (endHandle.getInstruction().opcode == Constants.DUP) {
+ nextHandle = endHandle.getNext();
retargetFrom(newHandle, nextHandle);
retargetFrom(endHandle, nextHandle);
- } else if (endHandle.getInstruction().opcode==Constants.DUP_X1) {
+ } else if (endHandle.getInstruction().opcode == Constants.DUP_X1) {
InstructionHandle dupHandle = endHandle;
endHandle = endHandle.getNext();
nextHandle = endHandle.getNext();
- if (endHandle.getInstruction().opcode==Constants.SWAP) {}
- else {
+ if (endHandle.getInstruction().opcode == Constants.SWAP) {
+ } else {
// XXX see next XXX comment
throw new RuntimeException("Unhandled kind of new " + endHandle);
}
throw new BCException("shouldn't happen");
}
}
+
private void retargetFrom(InstructionHandle old, InstructionHandle fresh) {
InstructionTargeter[] sources = old.getTargetersArray();
if (sources != null) {
for (int i = sources.length - 1; i >= 0; i--) {
if (sources[i] instanceof ExceptionRange) {
- ExceptionRange it = (ExceptionRange)sources[i];
+ ExceptionRange it = (ExceptionRange) sources[i];
System.err.println("...");
- it.updateTarget(old,fresh,it.getBody());
+ it.updateTarget(old, fresh, it.getBody());
} else {
- sources[i].updateTarget(old, fresh);
+ sources[i].updateTarget(old, fresh);
}
}
}
}
-
+
// records advice that is stopping us doing the lazyTjp optimization
private List badAdvice = null;
-
+
public void addAdvicePreventingLazyTjp(BcelAdvice advice) {
- if (badAdvice == null) badAdvice = new ArrayList();
+ if (badAdvice == null)
+ badAdvice = new ArrayList();
badAdvice.add(advice);
}
-
- protected void prepareForMungers() {
- // if we're a constructor call, we need to remove the new:dup or the new:dup_x1:swap,
+
+ protected void prepareForMungers() {
+ // if we're a constructor call, we need to remove the new:dup or the new:dup_x1:swap,
// and store all our
// arguments on the frame.
-
- // ??? This is a bit of a hack (for the Java langauge). We do this because
- // we sometime add code "outsideBefore" when dealing with weaving join points. We only
- // do this for exposing state that is on the stack. It turns out to just work for
- // everything except for constructor calls and exception handlers. If we were to clean
- // this up, every ShadowRange would have three instructionHandle points, the start of
+
+ // ??? This is a bit of a hack (for the Java langauge). We do this because
+ // we sometime add code "outsideBefore" when dealing with weaving join points. We only
+ // do this for exposing state that is on the stack. It turns out to just work for
+ // everything except for constructor calls and exception handlers. If we were to clean
+ // this up, every ShadowRange would have three instructionHandle points, the start of
// the arg-setup code, the start of the running code, and the end of the running code.
if (getKind() == ConstructorCall) {
if (!world.isJoinpointArrayConstructionEnabled() || !this.getSignature().getDeclaringType().isArray())
- deleteNewAndDup(); // no new/dup for new array construction
+ deleteNewAndDup(); // no new/dup for new array construction
initializeArgVars();
} else if (getKind() == PreInitialization) { // pr74952
ShadowRange range = getRange();
- range.insert(InstructionConstants.NOP,Range.InsideAfter);
+ range.insert(InstructionConstants.NOP, Range.InsideAfter);
} else if (getKind() == ExceptionHandler) {
-
+
ShadowRange range = getRange();
InstructionList body = range.getBody();
- InstructionHandle start = range.getStart();
-
- // Create a store instruction to put the value from the top of the
- // stack into a local variable slot. This is a trimmed version of
+ InstructionHandle start = range.getStart();
+
+ // Create a store instruction to put the value from the top of the
+ // stack into a local variable slot. This is a trimmed version of
// what is in initializeArgVars() (since there is only one argument
// at a handler jp and only before advice is supported) (pr46298)
- argVars = new BcelVar[1];
- //int positionOffset = (hasTarget() ? 1 : 0) + ((hasThis() && !getKind().isTargetSameAsThis()) ? 1 : 0);
+ argVars = new BcelVar[1];
+ // int positionOffset = (hasTarget() ? 1 : 0) + ((hasThis() && !getKind().isTargetSameAsThis()) ? 1 : 0);
UnresolvedType tx = getArgType(0);
- argVars[0] = genTempVar(tx, "ajc$arg0");
- InstructionHandle insertedInstruction =
- range.insert(argVars[0].createStore(getFactory()), Range.OutsideBefore);
+ argVars[0] = genTempVar(tx, "ajc$arg0");
+ InstructionHandle insertedInstruction = range.insert(argVars[0].createStore(getFactory()), Range.OutsideBefore);
- // Now the exception range starts just after our new instruction.
- // The next bit of code changes the exception range to point at
- // the store instruction
+ // Now the exception range starts just after our new instruction.
+ // The next bit of code changes the exception range to point at
+ // the store instruction
InstructionTargeter[] targeters = start.getTargetersArray();
for (int i = 0; i < targeters.length; i++) {
InstructionTargeter t = targeters[i];
}
// now we ask each munger to request our state
- isThisJoinPointLazy = true;//world.isXlazyTjp(); // lazy is default now
+ isThisJoinPointLazy = true;// world.isXlazyTjp(); // lazy is default now
badAdvice = null;
for (Iterator iter = mungers.iterator(); iter.hasNext();) {
ShadowMunger munger = (ShadowMunger) iter.next();
munger.specializeOn(this);
}
-
-
+
initializeThisJoinPoint();
- if (thisJoinPointVar!=null && !isThisJoinPointLazy && badAdvice!=null && badAdvice.size()>1) {
+ if (thisJoinPointVar != null && !isThisJoinPointLazy && badAdvice != null && badAdvice.size() > 1) {
// something stopped us making it a lazy tjp
// can't build tjp lazily, no suitable test...
int valid = 0;
for (Iterator iter = badAdvice.iterator(); iter.hasNext();) {
BcelAdvice element = (BcelAdvice) iter.next();
ISourceLocation sLoc = element.getSourceLocation();
- if (sLoc!=null && sLoc.getLine()>0) valid++;
+ if (sLoc != null && sLoc.getLine() > 0)
+ valid++;
}
- if (valid!=0) {
+ if (valid != 0) {
ISourceLocation[] badLocs = new ISourceLocation[valid];
int i = 0;
for (Iterator iter = badAdvice.iterator(); iter.hasNext();) {
BcelAdvice element = (BcelAdvice) iter.next();
ISourceLocation sLoc = element.getSourceLocation();
- if (sLoc!=null) badLocs[i++]=sLoc;
+ if (sLoc != null)
+ badLocs[i++] = sLoc;
}
- world.getLint().multipleAdviceStoppingLazyTjp.signal(
- new String[] {this.toString()},
- getSourceLocation(),badLocs
- );
+ world.getLint().multipleAdviceStoppingLazyTjp
+ .signal(new String[] { this.toString() }, getSourceLocation(), badLocs);
}
}
- badAdvice=null;
-
-
- // If we are an expression kind, we require our target/arguments on the stack
- // before we do our actual thing. However, they may have been removed
- // from the stack as the shadowMungers have requested state.
- // if any of our shadowMungers requested either the arguments or target,
- // the munger will have added code
- // to pop the target/arguments into temporary variables, represented by
- // targetVar and argVars. In such a case, we must make sure to re-push the
- // values.
-
- // If we are nonExpressionKind, we don't expect arguments on the stack
- // so this is moot. If our argVars happen to be null, then we know that
- // no ShadowMunger has squirrelled away our arguments, so they're still
- // on the stack.
+ badAdvice = null;
+
+ // If we are an expression kind, we require our target/arguments on the stack
+ // before we do our actual thing. However, they may have been removed
+ // from the stack as the shadowMungers have requested state.
+ // if any of our shadowMungers requested either the arguments or target,
+ // the munger will have added code
+ // to pop the target/arguments into temporary variables, represented by
+ // targetVar and argVars. In such a case, we must make sure to re-push the
+ // values.
+
+ // If we are nonExpressionKind, we don't expect arguments on the stack
+ // so this is moot. If our argVars happen to be null, then we know that
+ // no ShadowMunger has squirrelled away our arguments, so they're still
+ // on the stack.
InstructionFactory fact = getFactory();
if (getKind().argsOnStack() && argVars != null) {
-
- // Special case first (pr46298). If we are an exception handler and the instruction
- // just after the shadow is a POP then we should remove the pop. The code
+
+ // Special case first (pr46298). If we are an exception handler and the instruction
+ // just after the shadow is a POP then we should remove the pop. The code
// above which generated the store instruction has already cleared the stack.
// We also don't generate any code for the arguments in this case as it would be
// an incorrect aload.
- if (getKind() == ExceptionHandler
- && range.getEnd().getNext().getInstruction().equals(InstructionConstants.POP)) {
+ if (getKind() == ExceptionHandler && range.getEnd().getNext().getInstruction().equals(InstructionConstants.POP)) {
// easier than deleting it ...
range.getEnd().getNext().setInstruction(InstructionConstants.NOP);
} else {
- range.insert(
- BcelRenderer.renderExprs(fact, world, argVars),
- Range.InsideBefore);
- if (targetVar != null) {
- range.insert(
- BcelRenderer.renderExpr(fact, world, targetVar),
- Range.InsideBefore);
- }
- if (getKind() == ConstructorCall) {
- if (!world.isJoinpointArrayConstructionEnabled() || !this.getSignature().getDeclaringType().isArray()) {
- range.insert(InstructionFactory.createDup(1), Range.InsideBefore);
- range.insert(
- fact.createNew(
- (ObjectType) BcelWorld.makeBcelType(
- getSignature().getDeclaringType())),
- Range.InsideBefore);
- }
- }
+ range.insert(BcelRenderer.renderExprs(fact, world, argVars), Range.InsideBefore);
+ if (targetVar != null) {
+ range.insert(BcelRenderer.renderExpr(fact, world, targetVar), Range.InsideBefore);
+ }
+ if (getKind() == ConstructorCall) {
+ if (!world.isJoinpointArrayConstructionEnabled() || !this.getSignature().getDeclaringType().isArray()) {
+ range.insert(InstructionFactory.createDup(1), Range.InsideBefore);
+ range.insert(fact.createNew((ObjectType) BcelWorld.makeBcelType(getSignature().getDeclaringType())),
+ Range.InsideBefore);
+ }
+ }
}
}
- }
+ }
+
+ // ---- getters
- // ---- getters
+ public ShadowRange getRange() {
+ return range;
+ }
- public ShadowRange getRange() {
- return range;
- }
public void setRange(ShadowRange range) {
this.range = range;
}
-
+
private int sourceline = -1;
-
- public int getSourceLine() {
- // if the kind of join point for which we are a shadow represents
- // a method or constructor execution, then the best source line is
- // the one from the enclosingMethod declarationLineNumber if available.
- if (sourceline!=-1) return sourceline;
- Kind kind = getKind();
- if ( (kind == MethodExecution) ||
- (kind == ConstructorExecution) ||
- (kind == AdviceExecution) ||
- (kind == StaticInitialization) ||
- (kind == PreInitialization) ||
- (kind == Initialization)) {
- if (getEnclosingMethod().hasDeclaredLineNumberInfo()) {
- sourceline= getEnclosingMethod().getDeclarationLineNumber();
- return sourceline;
- }
- }
-
- if (range == null) {
- if (getEnclosingMethod().hasBody()) {
- sourceline= Utility.getSourceLine(getEnclosingMethod().getBody().getStart());
- return sourceline;
- } else {
- sourceline= 0;
- return sourceline;
- }
- }
- sourceline = Utility.getSourceLine(range.getStart());
- if (sourceline < 0) sourceline = 0;
- return sourceline;
- }
-
- // overrides
- public UnresolvedType getEnclosingType() {
- return getEnclosingClass().getType();
- }
-
- public LazyClassGen getEnclosingClass() {
- return enclosingMethod.getEnclosingClass();
- }
-
- public BcelWorld getWorld() {
- return world;
- }
-
- // ---- factory methods
-
- public static BcelShadow makeConstructorExecution(
- BcelWorld world,
- LazyMethodGen enclosingMethod,
- InstructionHandle justBeforeStart)
- {
+
+ public int getSourceLine() {
+ // if the kind of join point for which we are a shadow represents
+ // a method or constructor execution, then the best source line is
+ // the one from the enclosingMethod declarationLineNumber if available.
+ if (sourceline != -1)
+ return sourceline;
+ Kind kind = getKind();
+ if ((kind == MethodExecution) || (kind == ConstructorExecution) || (kind == AdviceExecution)
+ || (kind == StaticInitialization) || (kind == PreInitialization) || (kind == Initialization)) {
+ if (getEnclosingMethod().hasDeclaredLineNumberInfo()) {
+ sourceline = getEnclosingMethod().getDeclarationLineNumber();
+ return sourceline;
+ }
+ }
+
+ if (range == null) {
+ if (getEnclosingMethod().hasBody()) {
+ sourceline = Utility.getSourceLine(getEnclosingMethod().getBody().getStart());
+ return sourceline;
+ } else {
+ sourceline = 0;
+ return sourceline;
+ }
+ }
+ sourceline = Utility.getSourceLine(range.getStart());
+ if (sourceline < 0)
+ sourceline = 0;
+ return sourceline;
+ }
+
+ // overrides
+ public UnresolvedType getEnclosingType() {
+ return getEnclosingClass().getType();
+ }
+
+ public LazyClassGen getEnclosingClass() {
+ return enclosingMethod.getEnclosingClass();
+ }
+
+ public BcelWorld getWorld() {
+ return world;
+ }
+
+ // ---- factory methods
+
+ public static BcelShadow makeConstructorExecution(BcelWorld world, LazyMethodGen enclosingMethod,
+ InstructionHandle justBeforeStart) {
final InstructionList body = enclosingMethod.getBody();
- BcelShadow s =
- new BcelShadow(
- world,
- ConstructorExecution,
- world.makeJoinPointSignatureFromMethod(enclosingMethod,Member.CONSTRUCTOR),
- enclosingMethod,
- null);
+ BcelShadow s = new BcelShadow(world, ConstructorExecution, world.makeJoinPointSignatureFromMethod(enclosingMethod,
+ Member.CONSTRUCTOR), enclosingMethod, null);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, justBeforeStart.getNext()),
- Range.genEnd(body));
+ r.associateWithTargets(Range.genStart(body, justBeforeStart.getNext()), Range.genEnd(body));
return s;
}
- public static BcelShadow makeStaticInitialization(
- BcelWorld world,
- LazyMethodGen enclosingMethod)
- {
- InstructionList body = enclosingMethod.getBody();
- // move the start past ajc$preClinit
- InstructionHandle clinitStart = body.getStart();
- if (clinitStart.getInstruction() instanceof InvokeInstruction) {
- InvokeInstruction ii = (InvokeInstruction)clinitStart.getInstruction();
- if (ii
- .getName(enclosingMethod.getEnclosingClass().getConstantPool())
- .equals(NameMangler.AJC_PRE_CLINIT_NAME)) {
+ public static BcelShadow makeStaticInitialization(BcelWorld world, LazyMethodGen enclosingMethod) {
+ InstructionList body = enclosingMethod.getBody();
+ // move the start past ajc$preClinit
+ InstructionHandle clinitStart = body.getStart();
+ if (clinitStart.getInstruction() instanceof InvokeInstruction) {
+ InvokeInstruction ii = (InvokeInstruction) clinitStart.getInstruction();
+ if (ii.getName(enclosingMethod.getEnclosingClass().getConstantPool()).equals(NameMangler.AJC_PRE_CLINIT_NAME)) {
clinitStart = clinitStart.getNext();
}
- }
-
- InstructionHandle clinitEnd = body.getEnd();
-
- //XXX should move the end before the postClinit, but the return is then tricky...
-// if (clinitEnd.getInstruction() instanceof InvokeInstruction) {
-// InvokeInstruction ii = (InvokeInstruction)clinitEnd.getInstruction();
-// if (ii.getName(enclosingMethod.getEnclosingClass().getConstantPool()).equals(NameMangler.AJC_POST_CLINIT_NAME)) {
-// clinitEnd = clinitEnd.getPrev();
-// }
-// }
-
-
-
- BcelShadow s =
- new BcelShadow(
- world,
- StaticInitialization,
- world.makeJoinPointSignatureFromMethod(enclosingMethod,Member.STATIC_INITIALIZATION),
- enclosingMethod,
- null);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, clinitStart),
- Range.genEnd(body, clinitEnd));
- return s;
- }
-
- /** Make the shadow for an exception handler. Currently makes an empty shadow that
- * only allows before advice to be woven into it.
- */
+ }
+ InstructionHandle clinitEnd = body.getEnd();
- public static BcelShadow makeExceptionHandler(
- BcelWorld world,
- ExceptionRange exceptionRange,
- LazyMethodGen enclosingMethod,
- InstructionHandle startOfHandler,
- BcelShadow enclosingShadow)
- {
+ // XXX should move the end before the postClinit, but the return is then tricky...
+ // if (clinitEnd.getInstruction() instanceof InvokeInstruction) {
+ // InvokeInstruction ii = (InvokeInstruction)clinitEnd.getInstruction();
+ // if (ii.getName(enclosingMethod.getEnclosingClass().getConstantPool()).equals(NameMangler.AJC_POST_CLINIT_NAME)) {
+ // clinitEnd = clinitEnd.getPrev();
+ // }
+ // }
+
+ BcelShadow s = new BcelShadow(world, StaticInitialization, world.makeJoinPointSignatureFromMethod(enclosingMethod,
+ Member.STATIC_INITIALIZATION), enclosingMethod, null);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, clinitStart), Range.genEnd(body, clinitEnd));
+ return s;
+ }
+
+ /**
+ * Make the shadow for an exception handler. Currently makes an empty shadow that only allows before advice to be woven into it.
+ */
+
+ public static BcelShadow makeExceptionHandler(BcelWorld world, ExceptionRange exceptionRange, LazyMethodGen enclosingMethod,
+ InstructionHandle startOfHandler, BcelShadow enclosingShadow) {
InstructionList body = enclosingMethod.getBody();
UnresolvedType catchType = exceptionRange.getCatchType();
UnresolvedType inType = enclosingMethod.getEnclosingClass().getType();
-
- ResolvedMemberImpl sig = MemberImpl.makeExceptionHandlerSignature(inType, catchType);
- sig.setParameterNames(new String[] {findHandlerParamName(startOfHandler)});
-
- BcelShadow s =
- new BcelShadow(
- world,
- ExceptionHandler,
- sig,
- enclosingMethod,
- enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- InstructionHandle start = Range.genStart(body, startOfHandler);
- InstructionHandle end = Range.genEnd(body, start);
-
- r.associateWithTargets(start, end);
- exceptionRange.updateTarget(startOfHandler, start, body);
- return s;
- }
-
- private static String findHandlerParamName(InstructionHandle startOfHandler) {
- if (startOfHandler.getInstruction().isStoreInstruction() &&
- startOfHandler.getNext() != null)
- {
+
+ ResolvedMemberImpl sig = MemberImpl.makeExceptionHandlerSignature(inType, catchType);
+ sig.setParameterNames(new String[] { findHandlerParamName(startOfHandler) });
+
+ BcelShadow s = new BcelShadow(world, ExceptionHandler, sig, enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ InstructionHandle start = Range.genStart(body, startOfHandler);
+ InstructionHandle end = Range.genEnd(body, start);
+
+ r.associateWithTargets(start, end);
+ exceptionRange.updateTarget(startOfHandler, start, body);
+ return s;
+ }
+
+ private static String findHandlerParamName(InstructionHandle startOfHandler) {
+ if (startOfHandler.getInstruction().isStoreInstruction() && startOfHandler.getNext() != null) {
int slot = startOfHandler.getInstruction().getIndex();
- //System.out.println("got store: " + startOfHandler.getInstruction() + ", " + index);
+ // System.out.println("got store: " + startOfHandler.getInstruction() + ", " + index);
Iterator tIter = startOfHandler.getNext().getTargeters().iterator();
while (tIter.hasNext()) {
- InstructionTargeter targeter = (InstructionTargeter)tIter.next();
+ InstructionTargeter targeter = (InstructionTargeter) tIter.next();
if (targeter instanceof LocalVariableTag) {
- LocalVariableTag t = (LocalVariableTag)targeter;
+ LocalVariableTag t = (LocalVariableTag) targeter;
if (t.getSlot() == slot) {
return t.getName();
}
}
}
}
-
+
return "<missing>";
}
-
- /** create an init join point associated w/ an interface in the body of a constructor */
-
- public static BcelShadow makeIfaceInitialization(
- BcelWorld world,
- LazyMethodGen constructor,
- Member interfaceConstructorSignature)
- {
+
+ /** create an init join point associated w/ an interface in the body of a constructor */
+
+ public static BcelShadow makeIfaceInitialization(BcelWorld world, LazyMethodGen constructor,
+ Member interfaceConstructorSignature) {
// this call marks the instruction list as changed
constructor.getBody();
// UnresolvedType inType = constructor.getEnclosingClass().getType();
- BcelShadow s =
- new BcelShadow(
- world,
- Initialization,
- interfaceConstructorSignature,
- constructor,
- null);
-// s.fallsThrough = true;
-// ShadowRange r = new ShadowRange(body);
-// r.associateWithShadow(s);
-// InstructionHandle start = Range.genStart(body, handle);
-// InstructionHandle end = Range.genEnd(body, handle);
-//
-// r.associateWithTargets(start, end);
- return s;
- }
-
+ BcelShadow s = new BcelShadow(world, Initialization, interfaceConstructorSignature, constructor, null);
+ // s.fallsThrough = true;
+ // ShadowRange r = new ShadowRange(body);
+ // r.associateWithShadow(s);
+ // InstructionHandle start = Range.genStart(body, handle);
+ // InstructionHandle end = Range.genEnd(body, handle);
+ //
+ // r.associateWithTargets(start, end);
+ return s;
+ }
+
public void initIfaceInitializer(InstructionHandle end) {
final InstructionList body = enclosingMethod.getBody();
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(this);
InstructionHandle nop = body.insert(end, InstructionConstants.NOP);
-
- r.associateWithTargets(
- Range.genStart(body, nop),
- Range.genEnd(body, nop));
- }
-
-// public static BcelShadow makeIfaceConstructorExecution(
-// BcelWorld world,
-// LazyMethodGen constructor,
-// InstructionHandle next,
-// Member interfaceConstructorSignature)
-// {
-// // final InstructionFactory fact = constructor.getEnclosingClass().getFactory();
-// InstructionList body = constructor.getBody();
-// // UnresolvedType inType = constructor.getEnclosingClass().getType();
-// BcelShadow s =
-// new BcelShadow(
-// world,
-// ConstructorExecution,
-// interfaceConstructorSignature,
-// constructor,
-// null);
-// s.fallsThrough = true;
-// ShadowRange r = new ShadowRange(body);
-// r.associateWithShadow(s);
-// // ??? this may or may not work
-// InstructionHandle start = Range.genStart(body, next);
-// //InstructionHandle end = Range.genEnd(body, body.append(start, fact.NOP));
-// InstructionHandle end = Range.genStart(body, next);
-// //body.append(start, fact.NOP);
-//
-// r.associateWithTargets(start, end);
-// return s;
-// }
-
-
- /** Create an initialization join point associated with a constructor, but not
- * with any body of code yet. If this is actually matched, it's range will be set
- * when we inline self constructors.
- *
- * @param constructor The constructor starting this initialization.
- */
- public static BcelShadow makeUnfinishedInitialization(
- BcelWorld world,
- LazyMethodGen constructor)
- {
- BcelShadow ret = new BcelShadow(
- world,
- Initialization,
- world.makeJoinPointSignatureFromMethod(constructor,Member.CONSTRUCTOR),
- constructor,
- null);
+
+ r.associateWithTargets(Range.genStart(body, nop), Range.genEnd(body, nop));
+ }
+
+ // public static BcelShadow makeIfaceConstructorExecution(
+ // BcelWorld world,
+ // LazyMethodGen constructor,
+ // InstructionHandle next,
+ // Member interfaceConstructorSignature)
+ // {
+ // // final InstructionFactory fact = constructor.getEnclosingClass().getFactory();
+ // InstructionList body = constructor.getBody();
+ // // UnresolvedType inType = constructor.getEnclosingClass().getType();
+ // BcelShadow s =
+ // new BcelShadow(
+ // world,
+ // ConstructorExecution,
+ // interfaceConstructorSignature,
+ // constructor,
+ // null);
+ // s.fallsThrough = true;
+ // ShadowRange r = new ShadowRange(body);
+ // r.associateWithShadow(s);
+ // // ??? this may or may not work
+ // InstructionHandle start = Range.genStart(body, next);
+ // //InstructionHandle end = Range.genEnd(body, body.append(start, fact.NOP));
+ // InstructionHandle end = Range.genStart(body, next);
+ // //body.append(start, fact.NOP);
+ //
+ // r.associateWithTargets(start, end);
+ // return s;
+ // }
+
+ /**
+ * Create an initialization join point associated with a constructor, but not with any body of code yet. If this is actually
+ * matched, it's range will be set when we inline self constructors.
+ *
+ * @param constructor The constructor starting this initialization.
+ */
+ public static BcelShadow makeUnfinishedInitialization(BcelWorld world, LazyMethodGen constructor) {
+ BcelShadow ret = new BcelShadow(world, Initialization, world.makeJoinPointSignatureFromMethod(constructor,
+ Member.CONSTRUCTOR), constructor, null);
if (constructor.getEffectiveSignature() != null) {
ret.setMatchingSignature(constructor.getEffectiveSignature().getEffectiveSignature());
}
return ret;
}
- public static BcelShadow makeUnfinishedPreinitialization(
- BcelWorld world,
- LazyMethodGen constructor)
- {
- BcelShadow ret = new BcelShadow(
- world,
- PreInitialization,
- world.makeJoinPointSignatureFromMethod(constructor,Member.CONSTRUCTOR),
- constructor,
- null);
+ public static BcelShadow makeUnfinishedPreinitialization(BcelWorld world, LazyMethodGen constructor) {
+ BcelShadow ret = new BcelShadow(world, PreInitialization, world.makeJoinPointSignatureFromMethod(constructor,
+ Member.CONSTRUCTOR), constructor, null);
if (constructor.getEffectiveSignature() != null) {
ret.setMatchingSignature(constructor.getEffectiveSignature().getEffectiveSignature());
}
return ret;
}
-
-
- public static BcelShadow makeMethodExecution(
- BcelWorld world,
- LazyMethodGen enclosingMethod,
- boolean lazyInit)
- {
- if (!lazyInit) return makeMethodExecution(world, enclosingMethod);
-
- BcelShadow s =
- new BcelShadow(
- world,
- MethodExecution,
- enclosingMethod.getMemberView(),
- enclosingMethod,
- null);
-
+
+ public static BcelShadow makeMethodExecution(BcelWorld world, LazyMethodGen enclosingMethod, boolean lazyInit) {
+ if (!lazyInit)
+ return makeMethodExecution(world, enclosingMethod);
+
+ BcelShadow s = new BcelShadow(world, MethodExecution, enclosingMethod.getMemberView(), enclosingMethod, null);
+
return s;
}
-
-
+
public void init() {
- if (range != null) return;
-
+ if (range != null)
+ return;
+
final InstructionList body = enclosingMethod.getBody();
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(this);
- r.associateWithTargets(
- Range.genStart(body),
- Range.genEnd(body));
- }
-
- public static BcelShadow makeMethodExecution(
- BcelWorld world,
- LazyMethodGen enclosingMethod)
- {
- return makeShadowForMethod(world, enclosingMethod, MethodExecution,
- enclosingMethod.getMemberView()); //world.makeMethodSignature(enclosingMethod));
- }
-
-
- public static BcelShadow makeShadowForMethod(BcelWorld world,
- LazyMethodGen enclosingMethod, Shadow.Kind kind, Member sig)
- {
- final InstructionList body = enclosingMethod.getBody();
- BcelShadow s =
- new BcelShadow(
- world,
- kind,
- sig,
- enclosingMethod,
- null);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(// OPTIMIZE this occurs lots of times for all jp kinds...
- Range.genStart(body),
- Range.genEnd(body));
- return s;
- }
-
-
-
- public static BcelShadow makeAdviceExecution(
- BcelWorld world,
- LazyMethodGen enclosingMethod)
- {
+ r.associateWithTargets(Range.genStart(body), Range.genEnd(body));
+ }
+
+ public static BcelShadow makeMethodExecution(BcelWorld world, LazyMethodGen enclosingMethod) {
+ return makeShadowForMethod(world, enclosingMethod, MethodExecution, enclosingMethod.getMemberView()); // world.
+ // makeMethodSignature
+ // (
+ // enclosingMethod))
+ // ;
+ }
+
+ public static BcelShadow makeShadowForMethod(BcelWorld world, LazyMethodGen enclosingMethod, Shadow.Kind kind, Member sig) {
final InstructionList body = enclosingMethod.getBody();
- BcelShadow s =
- new BcelShadow(
- world,
- AdviceExecution,
- world.makeJoinPointSignatureFromMethod(enclosingMethod, Member.ADVICE),
- enclosingMethod,
- null);
+ BcelShadow s = new BcelShadow(world, kind, sig, enclosingMethod, null);
ShadowRange r = new ShadowRange(body);
r.associateWithShadow(s);
- r.associateWithTargets(Range.genStart(body), Range.genEnd(body));
+ r.associateWithTargets(// OPTIMIZE this occurs lots of times for all jp kinds...
+ Range.genStart(body), Range.genEnd(body));
return s;
}
+ public static BcelShadow makeAdviceExecution(BcelWorld world, LazyMethodGen enclosingMethod) {
+ final InstructionList body = enclosingMethod.getBody();
+ BcelShadow s = new BcelShadow(world, AdviceExecution, world
+ .makeJoinPointSignatureFromMethod(enclosingMethod, Member.ADVICE), enclosingMethod, null);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body), Range.genEnd(body));
+ return s;
+ }
- // constructor call shadows are <em>initially</em> just around the
- // call to the constructor. If ANY advice gets put on it, we move
- // the NEW instruction inside the join point, which involves putting
+ // constructor call shadows are <em>initially</em> just around the
+ // call to the constructor. If ANY advice gets put on it, we move
+ // the NEW instruction inside the join point, which involves putting
// all the arguments in temps.
- public static BcelShadow makeConstructorCall(
- BcelWorld world,
- LazyMethodGen enclosingMethod,
- InstructionHandle callHandle,
- BcelShadow enclosingShadow)
- {
- final InstructionList body = enclosingMethod.getBody();
-
- Member sig = world.makeJoinPointSignatureForMethodInvocation(
- enclosingMethod.getEnclosingClass(),
- (InvokeInstruction) callHandle.getInstruction());
-
- BcelShadow s =
- new BcelShadow(
- world,
- ConstructorCall,
- sig,
- enclosingMethod,
- enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, callHandle),
- Range.genEnd(body, callHandle));
- retargetAllBranches(callHandle, r.getStart());
- return s;
- }
-
- public static BcelShadow makeArrayConstructorCall(BcelWorld world,LazyMethodGen enclosingMethod,InstructionHandle arrayInstruction,BcelShadow enclosingShadow) {
- final InstructionList body = enclosingMethod.getBody();
- Member sig = world.makeJoinPointSignatureForArrayConstruction(enclosingMethod.getEnclosingClass(),arrayInstruction);
- BcelShadow s =
- new BcelShadow(
- world,
- ConstructorCall,
- sig,
- enclosingMethod,
- enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, arrayInstruction),
- Range.genEnd(body, arrayInstruction));
- retargetAllBranches(arrayInstruction, r.getStart());
- return s;
- }
-
- public static BcelShadow makeMonitorEnter(BcelWorld world,LazyMethodGen enclosingMethod,InstructionHandle monitorInstruction,BcelShadow enclosingShadow) {
- final InstructionList body = enclosingMethod.getBody();
- Member sig = world.makeJoinPointSignatureForMonitorEnter(enclosingMethod.getEnclosingClass(),monitorInstruction);
- BcelShadow s = new BcelShadow(world,SynchronizationLock,sig,enclosingMethod,enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, monitorInstruction),
- Range.genEnd(body, monitorInstruction));
- retargetAllBranches(monitorInstruction, r.getStart());
- return s;
- }
-
- public static BcelShadow makeMonitorExit(BcelWorld world,LazyMethodGen enclosingMethod,InstructionHandle monitorInstruction,BcelShadow enclosingShadow) {
- final InstructionList body = enclosingMethod.getBody();
- Member sig = world.makeJoinPointSignatureForMonitorExit(enclosingMethod.getEnclosingClass(),monitorInstruction);
- BcelShadow s = new BcelShadow(world,SynchronizationUnlock,sig,enclosingMethod,enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, monitorInstruction),
- Range.genEnd(body, monitorInstruction));
- retargetAllBranches(monitorInstruction, r.getStart());
- return s;
- }
-
- // see pr77166
-// public static BcelShadow makeArrayLoadCall(
-// BcelWorld world,
-// LazyMethodGen enclosingMethod,
-// InstructionHandle arrayInstruction,
-// BcelShadow enclosingShadow)
-// {
-// final InstructionList body = enclosingMethod.getBody();
-// Member sig = world.makeJoinPointSignatureForArrayLoad(enclosingMethod.getEnclosingClass(),arrayInstruction);
-// BcelShadow s =
-// new BcelShadow(
-// world,
-// MethodCall,
-// sig,
-// enclosingMethod,
-// enclosingShadow);
-// ShadowRange r = new ShadowRange(body);
-// r.associateWithShadow(s);
-// r.associateWithTargets(
-// Range.genStart(body, arrayInstruction),
-// Range.genEnd(body, arrayInstruction));
-// retargetAllBranches(arrayInstruction, r.getStart());
-// return s;
-// }
-
- public static BcelShadow makeMethodCall(
- BcelWorld world,
- LazyMethodGen enclosingMethod,
- InstructionHandle callHandle,
- BcelShadow enclosingShadow)
- {
- final InstructionList body = enclosingMethod.getBody();
- BcelShadow s =
- new BcelShadow(
- world,
- MethodCall,
- world.makeJoinPointSignatureForMethodInvocation(
- enclosingMethod.getEnclosingClass(),
- (InvokeInstruction) callHandle.getInstruction()),
- enclosingMethod,
- enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, callHandle),
- Range.genEnd(body, callHandle));
- retargetAllBranches(callHandle, r.getStart());
- return s;
- }
-
-
- public static BcelShadow makeShadowForMethodCall(
- BcelWorld world,
- LazyMethodGen enclosingMethod,
- InstructionHandle callHandle,
- BcelShadow enclosingShadow,
- Kind kind,
- ResolvedMember sig)
- {
- final InstructionList body = enclosingMethod.getBody();
- BcelShadow s =
- new BcelShadow(
- world,
- kind,
- sig,
- enclosingMethod,
- enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, callHandle),
- Range.genEnd(body, callHandle));
- retargetAllBranches(callHandle, r.getStart());
- return s;
- }
-
-
- public static BcelShadow makeFieldGet(
- BcelWorld world,
- ResolvedMember field,
- LazyMethodGen enclosingMethod,
- InstructionHandle getHandle,
- BcelShadow enclosingShadow)
- {
- final InstructionList body = enclosingMethod.getBody();
- BcelShadow s =
- new BcelShadow(
- world,
- FieldGet,
- field,
-// BcelWorld.makeFieldSignature(
-// enclosingMethod.getEnclosingClass(),
-// (FieldInstruction) getHandle.getInstruction()),
- enclosingMethod,
- enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, getHandle),
- Range.genEnd(body, getHandle));
- retargetAllBranches(getHandle, r.getStart());
- return s;
- }
-
- public static BcelShadow makeFieldSet(
- BcelWorld world,
- ResolvedMember field,
- LazyMethodGen enclosingMethod,
- InstructionHandle setHandle,
- BcelShadow enclosingShadow)
- {
- final InstructionList body = enclosingMethod.getBody();
- BcelShadow s =
- new BcelShadow(
- world,
- FieldSet,
- field,
-// BcelWorld.makeFieldJoinPointSignature(
-// enclosingMethod.getEnclosingClass(),
-// (FieldInstruction) setHandle.getInstruction()),
- enclosingMethod,
- enclosingShadow);
- ShadowRange r = new ShadowRange(body);
- r.associateWithShadow(s);
- r.associateWithTargets(
- Range.genStart(body, setHandle),
- Range.genEnd(body, setHandle));
- retargetAllBranches(setHandle, r.getStart());
- return s;
- }
+ public static BcelShadow makeConstructorCall(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle callHandle,
+ BcelShadow enclosingShadow) {
+ final InstructionList body = enclosingMethod.getBody();
+
+ Member sig = world.makeJoinPointSignatureForMethodInvocation(enclosingMethod.getEnclosingClass(),
+ (InvokeInstruction) callHandle.getInstruction());
+
+ BcelShadow s = new BcelShadow(world, ConstructorCall, sig, enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, callHandle), Range.genEnd(body, callHandle));
+ retargetAllBranches(callHandle, r.getStart());
+ return s;
+ }
+
+ public static BcelShadow makeArrayConstructorCall(BcelWorld world, LazyMethodGen enclosingMethod,
+ InstructionHandle arrayInstruction, BcelShadow enclosingShadow) {
+ final InstructionList body = enclosingMethod.getBody();
+ Member sig = world.makeJoinPointSignatureForArrayConstruction(enclosingMethod.getEnclosingClass(), arrayInstruction);
+ BcelShadow s = new BcelShadow(world, ConstructorCall, sig, enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, arrayInstruction), Range.genEnd(body, arrayInstruction));
+ retargetAllBranches(arrayInstruction, r.getStart());
+ return s;
+ }
+
+ public static BcelShadow makeMonitorEnter(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle monitorInstruction,
+ BcelShadow enclosingShadow) {
+ final InstructionList body = enclosingMethod.getBody();
+ Member sig = world.makeJoinPointSignatureForMonitorEnter(enclosingMethod.getEnclosingClass(), monitorInstruction);
+ BcelShadow s = new BcelShadow(world, SynchronizationLock, sig, enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, monitorInstruction), Range.genEnd(body, monitorInstruction));
+ retargetAllBranches(monitorInstruction, r.getStart());
+ return s;
+ }
+
+ public static BcelShadow makeMonitorExit(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle monitorInstruction,
+ BcelShadow enclosingShadow) {
+ final InstructionList body = enclosingMethod.getBody();
+ Member sig = world.makeJoinPointSignatureForMonitorExit(enclosingMethod.getEnclosingClass(), monitorInstruction);
+ BcelShadow s = new BcelShadow(world, SynchronizationUnlock, sig, enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, monitorInstruction), Range.genEnd(body, monitorInstruction));
+ retargetAllBranches(monitorInstruction, r.getStart());
+ return s;
+ }
+
+ // see pr77166
+ // public static BcelShadow makeArrayLoadCall(
+ // BcelWorld world,
+ // LazyMethodGen enclosingMethod,
+ // InstructionHandle arrayInstruction,
+ // BcelShadow enclosingShadow)
+ // {
+ // final InstructionList body = enclosingMethod.getBody();
+ // Member sig = world.makeJoinPointSignatureForArrayLoad(enclosingMethod.getEnclosingClass(),arrayInstruction);
+ // BcelShadow s =
+ // new BcelShadow(
+ // world,
+ // MethodCall,
+ // sig,
+ // enclosingMethod,
+ // enclosingShadow);
+ // ShadowRange r = new ShadowRange(body);
+ // r.associateWithShadow(s);
+ // r.associateWithTargets(
+ // Range.genStart(body, arrayInstruction),
+ // Range.genEnd(body, arrayInstruction));
+ // retargetAllBranches(arrayInstruction, r.getStart());
+ // return s;
+ // }
+
+ public static BcelShadow makeMethodCall(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle callHandle,
+ BcelShadow enclosingShadow) {
+ final InstructionList body = enclosingMethod.getBody();
+ BcelShadow s = new BcelShadow(world, MethodCall, world.makeJoinPointSignatureForMethodInvocation(enclosingMethod
+ .getEnclosingClass(), (InvokeInstruction) callHandle.getInstruction()), enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, callHandle), Range.genEnd(body, callHandle));
+ retargetAllBranches(callHandle, r.getStart());
+ return s;
+ }
+
+ public static BcelShadow makeShadowForMethodCall(BcelWorld world, LazyMethodGen enclosingMethod, InstructionHandle callHandle,
+ BcelShadow enclosingShadow, Kind kind, ResolvedMember sig) {
+ final InstructionList body = enclosingMethod.getBody();
+ BcelShadow s = new BcelShadow(world, kind, sig, enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, callHandle), Range.genEnd(body, callHandle));
+ retargetAllBranches(callHandle, r.getStart());
+ return s;
+ }
+
+ public static BcelShadow makeFieldGet(BcelWorld world, ResolvedMember field, LazyMethodGen enclosingMethod,
+ InstructionHandle getHandle, BcelShadow enclosingShadow) {
+ final InstructionList body = enclosingMethod.getBody();
+ BcelShadow s = new BcelShadow(world, FieldGet, field,
+ // BcelWorld.makeFieldSignature(
+ // enclosingMethod.getEnclosingClass(),
+ // (FieldInstruction) getHandle.getInstruction()),
+ enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, getHandle), Range.genEnd(body, getHandle));
+ retargetAllBranches(getHandle, r.getStart());
+ return s;
+ }
+
+ public static BcelShadow makeFieldSet(BcelWorld world, ResolvedMember field, LazyMethodGen enclosingMethod,
+ InstructionHandle setHandle, BcelShadow enclosingShadow) {
+ final InstructionList body = enclosingMethod.getBody();
+ BcelShadow s = new BcelShadow(world, FieldSet, field,
+ // BcelWorld.makeFieldJoinPointSignature(
+ // enclosingMethod.getEnclosingClass(),
+ // (FieldInstruction) setHandle.getInstruction()),
+ enclosingMethod, enclosingShadow);
+ ShadowRange r = new ShadowRange(body);
+ r.associateWithShadow(s);
+ r.associateWithTargets(Range.genStart(body, setHandle), Range.genEnd(body, setHandle));
+ retargetAllBranches(setHandle, r.getStart());
+ return s;
+ }
public static void retargetAllBranches(InstructionHandle from, InstructionHandle to) {
InstructionTargeter[] sources = from.getTargetersArray();
}
}
-// // ---- type access methods
-// private ObjectType getTargetBcelType() {
-// return (ObjectType) BcelWorld.makeBcelType(getTargetType());
-// }
-// private Type getArgBcelType(int arg) {
-// return BcelWorld.makeBcelType(getArgType(arg));
-// }
+ // // ---- type access methods
+ // private ObjectType getTargetBcelType() {
+ // return (ObjectType) BcelWorld.makeBcelType(getTargetType());
+ // }
+ // private Type getArgBcelType(int arg) {
+ // return BcelWorld.makeBcelType(getArgType(arg));
+ // }
- // ---- kinding
+ // ---- kinding
/**
- * If the end of my range has no real instructions following then
- * my context needs a return at the end.
+ * If the end of my range has no real instructions following then my context needs a return at the end.
*/
- public boolean terminatesWithReturn() {
- return getRange().getRealNext() == null;
- }
-
- /**
+ public boolean terminatesWithReturn() {
+ return getRange().getRealNext() == null;
+ }
+
+ /**
* Is arg0 occupied with the value of this
*/
- public boolean arg0HoldsThis() {
- if (getKind().isEnclosingKind()) {
- return !getSignature().isStatic();
- } else if (enclosingShadow == null) {
- //XXX this is mostly right
- // this doesn't do the right thing for calls in the pre part of introduced constructors.
- return !enclosingMethod.isStatic();
- } else {
- return ((BcelShadow)enclosingShadow).arg0HoldsThis();
- }
- }
-
- // ---- argument getting methods
-
- private BcelVar thisVar = null;
- private BcelVar targetVar = null;
- private BcelVar[] argVars = null;
- private Map/*<UnresolvedType,BcelVar>*/ kindedAnnotationVars = null;
- private Map/*<UnresolvedType,BcelVar>*/ thisAnnotationVars = null;
- private Map/*<UnresolvedType,BcelVar>*/ targetAnnotationVars = null;
- private Map/*<UnresolvedType,BcelVar>*/[] argAnnotationVars = null;
- private Map/*<UnresolvedType,BcelVar>*/ withinAnnotationVars = null;
- private Map/*<UnresolvedType,BcelVar>*/ withincodeAnnotationVars = null;
-
- public Var getThisVar() {
- if (!hasThis()) {
- throw new IllegalStateException("no this");
- }
- initializeThisVar();
- return thisVar;
- }
+ public boolean arg0HoldsThis() {
+ if (getKind().isEnclosingKind()) {
+ return !getSignature().isStatic();
+ } else if (enclosingShadow == null) {
+ // XXX this is mostly right
+ // this doesn't do the right thing for calls in the pre part of introduced constructors.
+ return !enclosingMethod.isStatic();
+ } else {
+ return ((BcelShadow) enclosingShadow).arg0HoldsThis();
+ }
+ }
+
+ // ---- argument getting methods
+
+ private BcelVar thisVar = null;
+ private BcelVar targetVar = null;
+ private BcelVar[] argVars = null;
+ private Map/* <UnresolvedType,BcelVar> */kindedAnnotationVars = null;
+ private Map/* <UnresolvedType,BcelVar> */thisAnnotationVars = null;
+ private Map/* <UnresolvedType,BcelVar> */targetAnnotationVars = null;
+ private Map/* <UnresolvedType,BcelVar> */[] argAnnotationVars = null;
+ private Map/* <UnresolvedType,BcelVar> */withinAnnotationVars = null;
+ private Map/* <UnresolvedType,BcelVar> */withincodeAnnotationVars = null;
+
+ public Var getThisVar() {
+ if (!hasThis()) {
+ throw new IllegalStateException("no this");
+ }
+ initializeThisVar();
+ return thisVar;
+ }
+
public Var getThisAnnotationVar(UnresolvedType forAnnotationType) {
- if (!hasThis()) {
- throw new IllegalStateException("no this");
- }
- initializeThisAnnotationVars(); // FIXME asc Why bother with this if we always return one?
- // Even if we can't find one, we have to return one as we might have this annotation at runtime
- Var v = (Var) thisAnnotationVars.get(forAnnotationType);
- if (v==null)
- v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world),(BcelVar)getThisVar());
- return v;
- }
- public Var getTargetVar() {
- if (!hasTarget()) {
- throw new IllegalStateException("no target");
- }
- initializeTargetVar();
- return targetVar;
- }
- public Var getTargetAnnotationVar(UnresolvedType forAnnotationType) {
- if (!hasTarget()) {
- throw new IllegalStateException("no target");
- }
- initializeTargetAnnotationVars(); // FIXME asc why bother with this if we always return one?
- Var v =(Var) targetAnnotationVars.get(forAnnotationType);
- // Even if we can't find one, we have to return one as we might have this annotation at runtime
- if (v==null)
- v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world),(BcelVar)getTargetVar());
+ if (!hasThis()) {
+ throw new IllegalStateException("no this");
+ }
+ initializeThisAnnotationVars(); // FIXME asc Why bother with this if we always return one?
+ // Even if we can't find one, we have to return one as we might have this annotation at runtime
+ Var v = (Var) thisAnnotationVars.get(forAnnotationType);
+ if (v == null)
+ v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world), (BcelVar) getThisVar());
+ return v;
+ }
+
+ public Var getTargetVar() {
+ if (!hasTarget()) {
+ throw new IllegalStateException("no target");
+ }
+ initializeTargetVar();
+ return targetVar;
+ }
+
+ public Var getTargetAnnotationVar(UnresolvedType forAnnotationType) {
+ if (!hasTarget()) {
+ throw new IllegalStateException("no target");
+ }
+ initializeTargetAnnotationVars(); // FIXME asc why bother with this if we always return one?
+ Var v = (Var) targetAnnotationVars.get(forAnnotationType);
+ // Even if we can't find one, we have to return one as we might have this annotation at runtime
+ if (v == null)
+ v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world), (BcelVar) getTargetVar());
return v;
- }
- public Var getArgVar(int i) {
- initializeArgVars();
- return argVars[i];
- }
- public Var getArgAnnotationVar(int i,UnresolvedType forAnnotationType) {
+ }
+
+ public Var getArgVar(int i) {
+ initializeArgVars();
+ return argVars[i];
+ }
+
+ public Var getArgAnnotationVar(int i, UnresolvedType forAnnotationType) {
initializeArgAnnotationVars();
-
- Var v= (Var) argAnnotationVars[i].get(forAnnotationType);
- if (v==null)
- v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world),(BcelVar)getArgVar(i));
+
+ Var v = (Var) argAnnotationVars[i].get(forAnnotationType);
+ if (v == null)
+ v = new TypeAnnotationAccessVar(forAnnotationType.resolve(world), (BcelVar) getArgVar(i));
return v;
- }
- public Var getKindedAnnotationVar(UnresolvedType forAnnotationType) {
- initializeKindedAnnotationVars();
- return (Var) kindedAnnotationVars.get(forAnnotationType);
- }
+ }
+
+ public Var getKindedAnnotationVar(UnresolvedType forAnnotationType) {
+ initializeKindedAnnotationVars();
+ return (Var) kindedAnnotationVars.get(forAnnotationType);
+ }
+
public Var getWithinAnnotationVar(UnresolvedType forAnnotationType) {
initializeWithinAnnotationVars();
return (Var) withinAnnotationVars.get(forAnnotationType);
- }
+ }
+
public Var getWithinCodeAnnotationVar(UnresolvedType forAnnotationType) {
initializeWithinCodeAnnotationVars();
return (Var) withincodeAnnotationVars.get(forAnnotationType);
}
-
- // reflective thisJoinPoint support
- private BcelVar thisJoinPointVar = null;
- private boolean isThisJoinPointLazy;
- private int lazyTjpConsumers = 0;
- private BcelVar thisJoinPointStaticPartVar = null;
- // private BcelVar thisEnclosingJoinPointStaticPartVar = null;
-
+
+ // reflective thisJoinPoint support
+ private BcelVar thisJoinPointVar = null;
+ private boolean isThisJoinPointLazy;
+ private int lazyTjpConsumers = 0;
+ private BcelVar thisJoinPointStaticPartVar = null;
+
+ // private BcelVar thisEnclosingJoinPointStaticPartVar = null;
+
public final Var getThisJoinPointStaticPartVar() {
return getThisJoinPointStaticPartBcelVar();
}
+
public final Var getThisEnclosingJoinPointStaticPartVar() {
return getThisEnclosingJoinPointStaticPartBcelVar();
}
-
- public void requireThisJoinPoint(boolean hasGuardTest, boolean isAround) {
- if (!isAround){
+
+ public void requireThisJoinPoint(boolean hasGuardTest, boolean isAround) {
+ if (!isAround) {
if (!hasGuardTest) {
isThisJoinPointLazy = false;
} else {
lazyTjpConsumers++;
}
}
-// if (!hasGuardTest) {
-// isThisJoinPointLazy = false;
-// } else {
-// lazyTjpConsumers++;
-// }
- if (thisJoinPointVar == null) {
+ // if (!hasGuardTest) {
+ // isThisJoinPointLazy = false;
+ // } else {
+ // lazyTjpConsumers++;
+ // }
+ if (thisJoinPointVar == null) {
thisJoinPointVar = genTempVar(UnresolvedType.forName("org.aspectj.lang.JoinPoint"));
- }
- }
-
-
- public Var getThisJoinPointVar() {
- requireThisJoinPoint(false,false);
- return thisJoinPointVar;
- }
-
- void initializeThisJoinPoint() {
- if (thisJoinPointVar == null) return;
-
- if (isThisJoinPointLazy) {
- isThisJoinPointLazy = checkLazyTjp();
- }
-
+ }
+ }
+
+ public Var getThisJoinPointVar() {
+ requireThisJoinPoint(false, false);
+ return thisJoinPointVar;
+ }
+
+ void initializeThisJoinPoint() {
+ if (thisJoinPointVar == null)
+ return;
+
+ if (isThisJoinPointLazy) {
+ isThisJoinPointLazy = checkLazyTjp();
+ }
+
if (isThisJoinPointLazy) {
appliedLazyTjpOptimization = true;
createThisJoinPoint(); // make sure any state needed is initialized, but throw the instructions out
-
- if (lazyTjpConsumers == 1) return; // special case only one lazyTjpUser
-
+
+ if (lazyTjpConsumers == 1)
+ return; // special case only one lazyTjpUser
+
InstructionFactory fact = getFactory();
InstructionList il = new InstructionList();
il.append(InstructionConstants.ACONST_NULL);
il.append(thisJoinPointVar.createStore(fact));
range.insert(il, Range.OutsideBefore);
}
- }
-
- private boolean checkLazyTjp() {
- // check for around advice
- for (Iterator i = mungers.iterator(); i.hasNext();) {
+ }
+
+ private boolean checkLazyTjp() {
+ // check for around advice
+ for (Iterator i = mungers.iterator(); i.hasNext();) {
ShadowMunger munger = (ShadowMunger) i.next();
if (munger instanceof Advice) {
- if ( ((Advice)munger).getKind() == AdviceKind.Around) {
- if (munger.getSourceLocation()!=null) { // do we know enough to bother reporting?
+ if (((Advice) munger).getKind() == AdviceKind.Around) {
+ if (munger.getSourceLocation() != null) { // do we know enough to bother reporting?
if (world.getLint().canNotImplementLazyTjp.isEnabled()) {
- world.getLint().canNotImplementLazyTjp.signal(
- new String[] {toString()},
- getSourceLocation(),
- new ISourceLocation[] { munger.getSourceLocation() }
- );
+ world.getLint().canNotImplementLazyTjp.signal(new String[] { toString() }, getSourceLocation(),
+ new ISourceLocation[] { munger.getSourceLocation() });
}
}
return false;
}
}
}
-
- return true;
- }
-
- InstructionList loadThisJoinPoint() {
+
+ return true;
+ }
+
+ InstructionList loadThisJoinPoint() {
InstructionFactory fact = getFactory();
InstructionList il = new InstructionList();
- if (isThisJoinPointLazy) {
- // If we're lazy, build the join point right here.
- il.append(createThisJoinPoint());
-
- // Does someone else need it? If so, store it for later retrieval
- if (lazyTjpConsumers > 1) {
+ if (isThisJoinPointLazy) {
+ // If we're lazy, build the join point right here.
+ il.append(createThisJoinPoint());
+
+ // Does someone else need it? If so, store it for later retrieval
+ if (lazyTjpConsumers > 1) {
il.append(thisJoinPointVar.createStore(fact));
-
+
InstructionHandle end = il.append(thisJoinPointVar.createLoad(fact));
-
+
il.insert(InstructionFactory.createBranchInstruction(Constants.IFNONNULL, end));
il.insert(thisJoinPointVar.createLoad(fact));
- }
- } else {
- // If not lazy, its already been built and stored, just retrieve it
+ }
+ } else {
+ // If not lazy, its already been built and stored, just retrieve it
thisJoinPointVar.appendLoad(il, fact);
- }
-
+ }
+
return il;
- }
+ }
InstructionList createThisJoinPoint() {
InstructionFactory fact = getFactory();
InstructionList il = new InstructionList();
-
+
BcelVar staticPart = getThisJoinPointStaticPartBcelVar();
staticPart.appendLoad(il, fact);
if (hasThis()) {
- ((BcelVar)getThisVar()).appendLoad(il, fact);
+ ((BcelVar) getThisVar()).appendLoad(il, fact);
} else {
il.append(InstructionConstants.ACONST_NULL);
}
if (hasTarget()) {
- ((BcelVar)getTargetVar()).appendLoad(il, fact);
+ ((BcelVar) getTargetVar()).appendLoad(il, fact);
} else {
il.append(InstructionConstants.ACONST_NULL);
}
-
- switch(getArgCount()) {
- case 0:
- il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
- "makeJP", LazyClassGen.tjpType,
- new Type[] { LazyClassGen.staticTjpType,
- Type.OBJECT, Type.OBJECT},
- Constants.INVOKESTATIC));
- break;
- case 1:
- ((BcelVar)getArgVar(0)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
- il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
- "makeJP", LazyClassGen.tjpType,
- new Type[] { LazyClassGen.staticTjpType,
- Type.OBJECT, Type.OBJECT, Type.OBJECT},
- Constants.INVOKESTATIC));
- break;
- case 2:
- ((BcelVar)getArgVar(0)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
- ((BcelVar)getArgVar(1)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
- il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
- "makeJP", LazyClassGen.tjpType,
- new Type[] { LazyClassGen.staticTjpType,
- Type.OBJECT, Type.OBJECT, Type.OBJECT, Type.OBJECT},
- Constants.INVOKESTATIC));
- break;
- default:
- il.append(makeArgsObjectArray());
- il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory",
- "makeJP", LazyClassGen.tjpType,
- new Type[] { LazyClassGen.staticTjpType,
- Type.OBJECT, Type.OBJECT, new ArrayType(Type.OBJECT, 1)},
- Constants.INVOKESTATIC));
- break;
- }
-
+
+ switch (getArgCount()) {
+ case 0:
+ il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory", "makeJP", LazyClassGen.tjpType, new Type[] {
+ LazyClassGen.staticTjpType, Type.OBJECT, Type.OBJECT }, Constants.INVOKESTATIC));
+ break;
+ case 1:
+ ((BcelVar) getArgVar(0)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
+ il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory", "makeJP", LazyClassGen.tjpType, new Type[] {
+ LazyClassGen.staticTjpType, Type.OBJECT, Type.OBJECT, Type.OBJECT }, Constants.INVOKESTATIC));
+ break;
+ case 2:
+ ((BcelVar) getArgVar(0)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
+ ((BcelVar) getArgVar(1)).appendLoadAndConvert(il, fact, world.getCoreType(ResolvedType.OBJECT));
+ il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory", "makeJP", LazyClassGen.tjpType, new Type[] {
+ LazyClassGen.staticTjpType, Type.OBJECT, Type.OBJECT, Type.OBJECT, Type.OBJECT }, Constants.INVOKESTATIC));
+ break;
+ default:
+ il.append(makeArgsObjectArray());
+ il.append(fact.createInvoke("org.aspectj.runtime.reflect.Factory", "makeJP", LazyClassGen.tjpType, new Type[] {
+ LazyClassGen.staticTjpType, Type.OBJECT, Type.OBJECT, new ArrayType(Type.OBJECT, 1) }, Constants.INVOKESTATIC));
+ break;
+ }
+
return il;
}
- /**
- * Get the Var for the jpStaticPart
- * @return
- */
- public BcelVar getThisJoinPointStaticPartBcelVar() {
- return getThisJoinPointStaticPartBcelVar(false);
- }
-
- /**
- * Get the Var for the xxxxJpStaticPart, xxx = this or enclosing
- * @param isEnclosingJp true to have the enclosingJpStaticPart
- * @return
- */
- public BcelVar getThisJoinPointStaticPartBcelVar(final boolean isEnclosingJp) {
- if (thisJoinPointStaticPartVar == null) {
- Field field = getEnclosingClass().getTjpField(this, isEnclosingJp);
- ResolvedType sjpType = null;
- if (world.isTargettingAspectJRuntime12()) { // TAG:SUPPORTING12: We didn't have different jpsp types in 1.2
- sjpType = world.getCoreType(UnresolvedType.JOINPOINT_STATICPART);
- } else {
- sjpType = isEnclosingJp?
- world.getCoreType(UnresolvedType.JOINPOINT_ENCLOSINGSTATICPART):
- world.getCoreType(UnresolvedType.JOINPOINT_STATICPART);
- }
- thisJoinPointStaticPartVar = new BcelFieldRef(
- sjpType,
- getEnclosingClass().getClassName(),
- field.getName());
-// getEnclosingClass().warnOnAddedStaticInitializer(this,munger.getSourceLocation());
- }
- return thisJoinPointStaticPartVar;
- }
-
- /**
- * Get the Var for the enclosingJpStaticPart
- * @return
- */
- public BcelVar getThisEnclosingJoinPointStaticPartBcelVar() {
- if (enclosingShadow == null) {
- // the enclosing of an execution is itself
- return getThisJoinPointStaticPartBcelVar(true);
- } else {
- return ((BcelShadow)enclosingShadow).getThisJoinPointStaticPartBcelVar(true);
- }
- }
-
- //??? need to better understand all the enclosing variants
- public Member getEnclosingCodeSignature() {
- if (getKind().isEnclosingKind()) {
- return getSignature();
- } else if (getKind() == Shadow.PreInitialization) {
- // PreInit doesn't enclose code but its signature
- // is correctly the signature of the ctor.
- return getSignature();
- } else if (enclosingShadow == null) {
- return getEnclosingMethod().getMemberView();
- } else {
- return enclosingShadow.getSignature();
- }
- }
-
-
- private InstructionList makeArgsObjectArray() {
- InstructionFactory fact = getFactory();
- BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
- final InstructionList il = new InstructionList();
- int alen = getArgCount() ;
- il.append(Utility.createConstant(fact, alen));
- il.append(fact.createNewArray(Type.OBJECT, (short)1));
- arrayVar.appendStore(il, fact);
-
- int stateIndex = 0;
- for (int i = 0, len = getArgCount(); i<len; i++) {
- arrayVar.appendConvertableArrayStore(il, fact, stateIndex, (BcelVar)getArgVar(i));
- stateIndex++;
- }
- arrayVar.appendLoad(il, fact);
- return il;
- }
-
- // ---- initializing var tables
-
- /* initializing this is doesn't do anything, because this
- * is protected from side-effects, so we don't need to copy its location
- */
-
- private void initializeThisVar() {
- if (thisVar != null) return;
- thisVar = new BcelVar(getThisType().resolve(world), 0);
- thisVar.setPositionInAroundState(0);
- }
- public void initializeTargetVar() {
- InstructionFactory fact = getFactory();
- if (targetVar != null) return;
- if (getKind().isTargetSameAsThis()) {
- if (hasThis()) initializeThisVar();
- targetVar = thisVar;
- } else {
- initializeArgVars(); // gotta pop off the args before we find the target
- UnresolvedType type = getTargetType();
- type = ensureTargetTypeIsCorrect(type);
- targetVar = genTempVar(type, "ajc$target");
- range.insert(targetVar.createStore(fact), Range.OutsideBefore);
- targetVar.setPositionInAroundState(hasThis() ? 1 : 0);
- }
- }
-
- /* PR 72528
- * This method double checks the target type under certain conditions. The Java 1.4
- * compilers seem to take calls to clone methods on array types and create bytecode that
- * looks like clone is being called on Object. If we advise a clone call with around
- * advice we extract the call into a helper method which we can then refer to. Because the
- * type in the bytecode for the call to clone is Object we create a helper method with
- * an Object parameter - this is not correct as we have lost the fact that the actual
- * type is an array type. If we don't do the check below we will create code that fails
- * java verification. This method checks for the peculiar set of conditions and if they
- * are true, it has a sneak peek at the code before the call to see what is on the stack.
- */
- public UnresolvedType ensureTargetTypeIsCorrect(UnresolvedType tx) {
-
- Member msig = getSignature();
- if (msig.getArity()==0 &&
- getKind() == MethodCall &&
- msig.getName().charAt(0) == 'c' &&
- tx.equals(ResolvedType.OBJECT) &&
- msig.getReturnType().equals(ResolvedType.OBJECT) &&
- msig.getName().equals("clone")) {
-
- // Lets go back through the code from the start of the shadow
- InstructionHandle searchPtr = range.getStart().getPrev();
- while (Range.isRangeHandle(searchPtr) ||
- searchPtr.getInstruction().isStoreInstruction()) { // ignore this instruction - it doesnt give us the info we want
- searchPtr = searchPtr.getPrev();
- }
-
- // A load instruction may tell us the real type of what the clone() call is on
- if (searchPtr.getInstruction().isLoadInstruction()) {
- LocalVariableTag lvt = LazyMethodGen.getLocalVariableTag(searchPtr,searchPtr.getInstruction().getIndex());
- if (lvt!=null) return UnresolvedType.forSignature(lvt.getType());
- }
- // A field access instruction may tell us the real type of what the clone() call is on
- if (searchPtr.getInstruction() instanceof FieldInstruction) {
- FieldInstruction si = (FieldInstruction)searchPtr.getInstruction();
- Type t = si.getFieldType(getEnclosingClass().getConstantPool());
- return BcelWorld.fromBcel(t);
- }
- // A new array instruction obviously tells us it is an array type !
- if (searchPtr.getInstruction().opcode==Constants.ANEWARRAY) {
- //ANEWARRAY ana = (ANEWARRAY)searchPoint.getInstruction();
-// Type t = ana.getType(getEnclosingClass().getConstantPool());
- // Just use a standard java.lang.object array - that will work fine
- return BcelWorld.fromBcel(new ArrayType(Type.OBJECT,1));
- }
- // A multi new array instruction obviously tells us it is an array type !
- if (searchPtr.getInstruction() instanceof MULTIANEWARRAY) {
- MULTIANEWARRAY ana = (MULTIANEWARRAY)searchPtr.getInstruction();
- // Type t = ana.getType(getEnclosingClass().getConstantPool());
- // t = new ArrayType(t,ana.getDimensions());
- // Just use a standard java.lang.object array - that will work fine
- return BcelWorld.fromBcel(new ArrayType(Type.OBJECT,ana.getDimensions()));
- }
- throw new BCException("Can't determine real target of clone() when processing instruction "+
- searchPtr.getInstruction()+". Perhaps avoid selecting clone with your pointcut?");
- }
- return tx;
- }
-
-
- public void initializeArgVars() {
- if (argVars != null) return;
- InstructionFactory fact = getFactory();
- int len = getArgCount();
- argVars = new BcelVar[len];
- int positionOffset = (hasTarget() ? 1 : 0) +
- ((hasThis() && !getKind().isTargetSameAsThis()) ? 1 : 0);
-
- if (getKind().argsOnStack()) {
- // we move backwards because we're popping off the stack
- for (int i = len - 1; i >= 0; i--) {
- UnresolvedType type = getArgType(i);
- BcelVar tmp = genTempVar(type, "ajc$arg" + i);
- range.insert(tmp.createStore(getFactory()), Range.OutsideBefore);
- int position = i;
- position += positionOffset;
- tmp.setPositionInAroundState(position);
- argVars[i] = tmp;
- }
- } else {
- int index = 0;
- if (arg0HoldsThis()) index++;
-
- for (int i = 0; i < len; i++) {
- UnresolvedType type = getArgType(i);
- BcelVar tmp = genTempVar(type, "ajc$arg" + i);
- range.insert(tmp.createCopyFrom(fact, index), Range.OutsideBefore);
- argVars[i] = tmp;
- int position = i;
- position += positionOffset;
-// System.out.println("set position: " + tmp + ", " + position + " in " + this);
-// System.out.println(" hasThis: " + hasThis() + ", hasTarget: " + hasTarget());
- tmp.setPositionInAroundState(position);
- index += type.getSize();
- }
- }
- }
- public void initializeForAroundClosure() {
- initializeArgVars();
- if (hasTarget()) initializeTargetVar();
- if (hasThis()) initializeThisVar();
-// System.out.println("initialized: " + this + " thisVar = " + thisVar);
- }
-
- public void initializeThisAnnotationVars() {
- if (thisAnnotationVars != null) return;
- thisAnnotationVars = new HashMap();
- // populate..
- }
- public void initializeTargetAnnotationVars() {
- if (targetAnnotationVars != null) return;
- if (getKind().isTargetSameAsThis()) {
- if (hasThis()) initializeThisAnnotationVars();
- targetAnnotationVars = thisAnnotationVars;
- } else {
- targetAnnotationVars = new HashMap();
- ResolvedType[] rtx = this.getTargetType().resolve(world).getAnnotationTypes(); // what about annotations we havent gotten yet but we will get in subclasses?
- for (int i = 0; i < rtx.length; i++) {
- ResolvedType typeX = rtx[i];
- targetAnnotationVars.put(typeX,new TypeAnnotationAccessVar(typeX,(BcelVar)getTargetVar()));
- }
- // populate.
- }
- }
- public void initializeArgAnnotationVars() {
- if (argAnnotationVars != null) return;
- int numArgs = getArgCount();
- argAnnotationVars = new Map[numArgs];
- for (int i = 0; i < argAnnotationVars.length; i++) {
- argAnnotationVars[i] = new HashMap();
- //FIXME asc just delete this logic - we always build the Var on demand, as we don't know at weave time
- // what the full set of annotations could be (due to static/dynamic type differences...)
- }
- }
-
- protected ResolvedMember getRelevantMember(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType){
- if (foundMember != null){
- return foundMember;
- }
-
-
- foundMember = getSignature().resolve(world);
- if (foundMember == null && relevantMember != null) {
- foundMember = relevantType.lookupMemberWithSupersAndITDs(relevantMember);
- }
-
- // check the ITD'd dooberries
- List mungers = relevantType.resolve(world).getInterTypeMungers();
- for (Iterator iter = mungers.iterator(); iter.hasNext();) {
- BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
- if (typeMunger.getMunger() instanceof NewMethodTypeMunger ||
- typeMunger.getMunger() instanceof NewConstructorTypeMunger) {
- ResolvedMember fakerm = typeMunger.getSignature();
- if (fakerm.getName().equals(getSignature().getName()) &&
- fakerm.getParameterSignature().equals(getSignature().getParameterSignature())){
- if (foundMember.getKind()==ResolvedMember.CONSTRUCTOR){
- foundMember = AjcMemberMaker.interConstructor(
- relevantType,
- foundMember,
- typeMunger.getAspectType());
- } else {
- foundMember = AjcMemberMaker.interMethod(foundMember,
- typeMunger.getAspectType(), false);
- }
- // in the above.. what about if it's on an Interface? Can that happen?
- // then the last arg of the above should be true
- return foundMember;
- }
- }
- }
- return foundMember;
- }
-
- protected ResolvedType [] getAnnotations(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType){
- if (foundMember == null){
- // check the ITD'd dooberries
- List mungers = relevantType.resolve(world).getInterTypeMungers();
- for (Iterator iter = mungers.iterator(); iter.hasNext();) {
- BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
- if (typeMunger.getMunger() instanceof NewMethodTypeMunger ||
- typeMunger.getMunger() instanceof NewConstructorTypeMunger) {
- ResolvedMember fakerm = typeMunger.getSignature();
- //if (fakerm.hasAnnotations())
-
- ResolvedMember ajcMethod = (getSignature().getKind()==ResolvedMember.CONSTRUCTOR?
- AjcMemberMaker.postIntroducedConstructor(typeMunger.getAspectType(),fakerm.getDeclaringType(),fakerm.getParameterTypes()):
- AjcMemberMaker.interMethodDispatcher(fakerm,typeMunger.getAspectType()));
- //AjcMemberMaker.interMethodBody(fakerm,typeMunger.getAspectType()));
- ResolvedMember rmm = findMethod(typeMunger.getAspectType(),ajcMethod);
- if (fakerm.getName().equals(getSignature().getName()) &&
- fakerm.getParameterSignature().equals(getSignature().getParameterSignature())) {
- relevantType = typeMunger.getAspectType();
- foundMember = rmm;
- return foundMember.getAnnotationTypes();
- }
- }
- }
- // didn't find in ITDs, look in supers
- foundMember = relevantType.lookupMemberWithSupersAndITDs(relevantMember);
- if (foundMember == null) {
- throw new IllegalStateException("Couldn't find member " + relevantMember + " for type " + relevantType);
- }
- }
- return foundMember.getAnnotationTypes();
- }
-
- /**
- * By determining what "kind" of shadow we are, we can find out the
- * annotations on the appropriate element (method, field, constructor, type).
- * Then create one BcelVar entry in the map for each annotation, keyed by
- * annotation type.
+ /**
+ * Get the Var for the jpStaticPart
+ *
+ * @return
*/
- public void initializeKindedAnnotationVars() {
- if (kindedAnnotationVars != null) return;
- kindedAnnotationVars = new HashMap();
-
- // FIXME asc Refactor this code, there is duplication
- ResolvedType[] annotations = null;
- Member shadowSignature = getSignature();
- Member annotationHolder = getSignature();
- ResolvedType relevantType = shadowSignature.getDeclaringType().resolve(world);
-
- if (relevantType.isRawType() || relevantType.isParameterizedType()) relevantType = relevantType.getGenericType();
-
- if (getKind() == Shadow.StaticInitialization) {
- annotations = relevantType.resolve(world).getAnnotationTypes();
- } else if (getKind() == Shadow.MethodCall || getKind() == Shadow.ConstructorCall) {
- ResolvedMember foundMember = findMethod2(relevantType.resolve(world).getDeclaredMethods(),getSignature());
- annotations = getAnnotations(foundMember, shadowSignature, relevantType);
- annotationHolder = getRelevantMember(foundMember,shadowSignature,relevantType);
- relevantType = annotationHolder.getDeclaringType().resolve(world);
-
- } else if (getKind() == Shadow.FieldSet || getKind() == Shadow.FieldGet) {
- annotationHolder = findField(relevantType.getDeclaredFields(),getSignature());
-
- if (annotationHolder==null) {
- // check the ITD'd dooberries
- List mungers = relevantType.resolve(world).getInterTypeMungers();
- for (Iterator iter = mungers.iterator(); iter.hasNext();) {
- BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
- if (typeMunger.getMunger() instanceof NewFieldTypeMunger) {
- ResolvedMember fakerm = typeMunger.getSignature();
- //if (fakerm.hasAnnotations())
- ResolvedMember ajcMethod = AjcMemberMaker.interFieldInitializer(fakerm,typeMunger.getAspectType());
- ResolvedMember rmm = findMethod(typeMunger.getAspectType(),ajcMethod);
- if (fakerm.equals(getSignature())) {
- relevantType = typeMunger.getAspectType();
- annotationHolder = rmm;
- }
- }
- }
- }
- annotations = ((ResolvedMember)annotationHolder).getAnnotationTypes();
-
- } else if (getKind() == Shadow.MethodExecution || getKind() == Shadow.ConstructorExecution ||
- getKind() == Shadow.AdviceExecution) {
- //ResolvedMember rm[] = relevantType.getDeclaredMethods();
- ResolvedMember foundMember = findMethod2(relevantType.getDeclaredMethods(),getSignature());
-
- annotations = getAnnotations(foundMember, shadowSignature, relevantType);
- annotationHolder = foundMember;
- annotationHolder = getRelevantMember(foundMember, annotationHolder,relevantType);
-
- } else if (getKind() == Shadow.ExceptionHandler) {
- relevantType = getSignature().getParameterTypes()[0].resolve(world);
- annotations = relevantType.getAnnotationTypes();
- } else if (getKind() == Shadow.PreInitialization || getKind() == Shadow.Initialization) {
- ResolvedMember found = findMethod2(relevantType.getDeclaredMethods(),getSignature());
- annotations = found.getAnnotationTypes();
- }
-
- if (annotations == null) {
- // We can't have recognized the shadow - should blow up now to be on the safe side
- throw new BCException("Could not discover annotations for shadow: "+getKind());
- }
-
- for (int i = 0; i < annotations.length; i++) {
- ResolvedType annotationType = annotations[i];
- AnnotationAccessVar accessVar = new AnnotationAccessVar(getKind(),annotationType.resolve(world),relevantType,annotationHolder);
- kindedAnnotationVars.put(annotationType,accessVar);
- }
- }
-
- //FIXME asc whats the real diff between this one and the version in findMethod()?
- ResolvedMember findMethod2(ResolvedMember rm[], Member sig) {
- ResolvedMember found = null;
- // String searchString = getSignature().getName()+getSignature().getParameterSignature();
- for (int i = 0; i < rm.length && found==null; i++) {
- ResolvedMember member = rm[i];
- if (member.getName().equals(sig.getName()) && member.getParameterSignature().equals(sig.getParameterSignature()))
- found = member;
- }
- return found;
- }
-
- private ResolvedMember findMethod(ResolvedType aspectType, ResolvedMember ajcMethod) {
- ResolvedMember decMethods[] = aspectType.getDeclaredMethods();
- for (int i = 0; i < decMethods.length; i++) {
- ResolvedMember member = decMethods[i];
- if (member.equals(ajcMethod)) return member;
- }
- return null;
+ public BcelVar getThisJoinPointStaticPartBcelVar() {
+ return getThisJoinPointStaticPartBcelVar(false);
}
-
-
- private ResolvedMember findField(ResolvedMember[] members,Member lookingFor) {
- for (int i = 0; i < members.length; i++) {
- ResolvedMember member = members[i];
- if ( member.getName().equals(getSignature().getName()) &&
- member.getType().equals(getSignature().getType())) {
- return member;
- }
- }
- return null;
- }
-
-
- public void initializeWithinAnnotationVars() {
- if (withinAnnotationVars != null) return;
- withinAnnotationVars = new HashMap();
-
- ResolvedType[] annotations = getEnclosingType().resolve(world).getAnnotationTypes();
- for (int i = 0; i < annotations.length; i++) {
- ResolvedType ann = annotations[i];
- Kind k = Shadow.StaticInitialization;
- withinAnnotationVars.put(ann,new AnnotationAccessVar(k,ann,getEnclosingType(),null));
- }
- }
-
- public void initializeWithinCodeAnnotationVars() {
- if (withincodeAnnotationVars != null) return;
- withincodeAnnotationVars = new HashMap();
-
- // For some shadow we are interested in annotations on the method containing that shadow.
- ResolvedType[] annotations = getEnclosingMethod().getMemberView().getAnnotationTypes();
- for (int i = 0; i < annotations.length; i++) {
- ResolvedType ann = annotations[i];
- Kind k = (getEnclosingMethod().getMemberView().getKind()==Member.CONSTRUCTOR?
- Shadow.ConstructorExecution:Shadow.MethodExecution);
- withincodeAnnotationVars.put(ann,
- new AnnotationAccessVar(k,ann,getEnclosingType(),getEnclosingCodeSignature()));
- }
- }
-
-
- // ---- weave methods
-
- void weaveBefore(BcelAdvice munger) {
- range.insert(
- munger.getAdviceInstructions(this, null, range.getRealStart()),
- Range.InsideBefore);
- }
-
- public void weaveAfter(BcelAdvice munger) {
- weaveAfterThrowing(munger, UnresolvedType.THROWABLE);
- weaveAfterReturning(munger);
- }
-
/**
- * The basic strategy here is to add a set of instructions at the end of
- * the shadow range that dispatch the advice, and then return whatever the
- * shadow was going to return anyway.
+ * Get the Var for the xxxxJpStaticPart, xxx = this or enclosing
*
- * To achieve this, we note all the return statements in the advice, and
- * replace them with code that:
- * 1) stores the return value on top of the stack in a temp var
- * 2) jumps to the start of our advice block
- * 3) restores the return value at the end of the advice block before
- * ultimately returning
- *
- * We also need to bind the return value into a returning parameter, if the
- * advice specified one.
+ * @param isEnclosingJp true to have the enclosingJpStaticPart
+ * @return
*/
- public void weaveAfterReturning(BcelAdvice munger) {
- List returns = findReturnInstructions();
- boolean hasReturnInstructions = !returns.isEmpty();
-
- // list of instructions that handle the actual return from the join point
- InstructionList retList = new InstructionList();
-
- // variable that holds the return value
- BcelVar returnValueVar = null;
-
- if (hasReturnInstructions) {
- returnValueVar = generateReturnInstructions(returns,retList);
- } else {
- // we need at least one instruction, as the target for jumps
- retList.append(InstructionConstants.NOP);
- }
-
- // list of instructions for dispatching to the advice itself
- InstructionList advice = getAfterReturningAdviceDispatchInstructions(
- munger, retList.getStart());
-
- if (hasReturnInstructions) {
- InstructionHandle gotoTarget = advice.getStart();
- for (Iterator i = returns.iterator(); i.hasNext();) {
- InstructionHandle ih = (InstructionHandle) i.next();
- retargetReturnInstruction(munger.hasExtraParameter(), returnValueVar, gotoTarget, ih);
+ public BcelVar getThisJoinPointStaticPartBcelVar(final boolean isEnclosingJp) {
+ if (thisJoinPointStaticPartVar == null) {
+ Field field = getEnclosingClass().getTjpField(this, isEnclosingJp);
+ ResolvedType sjpType = null;
+ if (world.isTargettingAspectJRuntime12()) { // TAG:SUPPORTING12: We didn't have different jpsp types in 1.2
+ sjpType = world.getCoreType(UnresolvedType.JOINPOINT_STATICPART);
+ } else {
+ sjpType = isEnclosingJp ? world.getCoreType(UnresolvedType.JOINPOINT_ENCLOSINGSTATICPART) : world
+ .getCoreType(UnresolvedType.JOINPOINT_STATICPART);
}
- }
-
- range.append(advice);
- range.append(retList);
- }
+ thisJoinPointStaticPartVar = new BcelFieldRef(sjpType, getEnclosingClass().getClassName(), field.getName());
+ // getEnclosingClass().warnOnAddedStaticInitializer(this,munger.getSourceLocation());
+ }
+ return thisJoinPointStaticPartVar;
+ }
/**
- * @return a list of all the return instructions in the range of this shadow
+ * Get the Var for the enclosingJpStaticPart
+ *
+ * @return
*/
- private List findReturnInstructions() {
+ public BcelVar getThisEnclosingJoinPointStaticPartBcelVar() {
+ if (enclosingShadow == null) {
+ // the enclosing of an execution is itself
+ return getThisJoinPointStaticPartBcelVar(true);
+ } else {
+ return ((BcelShadow) enclosingShadow).getThisJoinPointStaticPartBcelVar(true);
+ }
+ }
+
+ // ??? need to better understand all the enclosing variants
+ public Member getEnclosingCodeSignature() {
+ if (getKind().isEnclosingKind()) {
+ return getSignature();
+ } else if (getKind() == Shadow.PreInitialization) {
+ // PreInit doesn't enclose code but its signature
+ // is correctly the signature of the ctor.
+ return getSignature();
+ } else if (enclosingShadow == null) {
+ return getEnclosingMethod().getMemberView();
+ } else {
+ return enclosingShadow.getSignature();
+ }
+ }
+
+ private InstructionList makeArgsObjectArray() {
+ InstructionFactory fact = getFactory();
+ BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
+ final InstructionList il = new InstructionList();
+ int alen = getArgCount();
+ il.append(Utility.createConstant(fact, alen));
+ il.append(fact.createNewArray(Type.OBJECT, (short) 1));
+ arrayVar.appendStore(il, fact);
+
+ int stateIndex = 0;
+ for (int i = 0, len = getArgCount(); i < len; i++) {
+ arrayVar.appendConvertableArrayStore(il, fact, stateIndex, (BcelVar) getArgVar(i));
+ stateIndex++;
+ }
+ arrayVar.appendLoad(il, fact);
+ return il;
+ }
+
+ // ---- initializing var tables
+
+ /*
+ * initializing this is doesn't do anything, because this is protected from side-effects, so we don't need to copy its location
+ */
+
+ private void initializeThisVar() {
+ if (thisVar != null)
+ return;
+ thisVar = new BcelVar(getThisType().resolve(world), 0);
+ thisVar.setPositionInAroundState(0);
+ }
+
+ public void initializeTargetVar() {
+ InstructionFactory fact = getFactory();
+ if (targetVar != null)
+ return;
+ if (getKind().isTargetSameAsThis()) {
+ if (hasThis())
+ initializeThisVar();
+ targetVar = thisVar;
+ } else {
+ initializeArgVars(); // gotta pop off the args before we find the target
+ UnresolvedType type = getTargetType();
+ type = ensureTargetTypeIsCorrect(type);
+ targetVar = genTempVar(type, "ajc$target");
+ range.insert(targetVar.createStore(fact), Range.OutsideBefore);
+ targetVar.setPositionInAroundState(hasThis() ? 1 : 0);
+ }
+ }
+
+ /*
+ * PR 72528 This method double checks the target type under certain conditions. The Java 1.4 compilers seem to take calls to
+ * clone methods on array types and create bytecode that looks like clone is being called on Object. If we advise a clone call
+ * with around advice we extract the call into a helper method which we can then refer to. Because the type in the bytecode for
+ * the call to clone is Object we create a helper method with an Object parameter - this is not correct as we have lost the fact
+ * that the actual type is an array type. If we don't do the check below we will create code that fails java verification. This
+ * method checks for the peculiar set of conditions and if they are true, it has a sneak peek at the code before the call to see
+ * what is on the stack.
+ */
+ public UnresolvedType ensureTargetTypeIsCorrect(UnresolvedType tx) {
+
+ Member msig = getSignature();
+ if (msig.getArity() == 0 && getKind() == MethodCall && msig.getName().charAt(0) == 'c' && tx.equals(ResolvedType.OBJECT)
+ && msig.getReturnType().equals(ResolvedType.OBJECT) && msig.getName().equals("clone")) {
+
+ // Lets go back through the code from the start of the shadow
+ InstructionHandle searchPtr = range.getStart().getPrev();
+ while (Range.isRangeHandle(searchPtr) || searchPtr.getInstruction().isStoreInstruction()) { // ignore this instruction -
+ // it doesnt give us the
+ // info we want
+ searchPtr = searchPtr.getPrev();
+ }
+
+ // A load instruction may tell us the real type of what the clone() call is on
+ if (searchPtr.getInstruction().isLoadInstruction()) {
+ LocalVariableTag lvt = LazyMethodGen.getLocalVariableTag(searchPtr, searchPtr.getInstruction().getIndex());
+ if (lvt != null)
+ return UnresolvedType.forSignature(lvt.getType());
+ }
+ // A field access instruction may tell us the real type of what the clone() call is on
+ if (searchPtr.getInstruction() instanceof FieldInstruction) {
+ FieldInstruction si = (FieldInstruction) searchPtr.getInstruction();
+ Type t = si.getFieldType(getEnclosingClass().getConstantPool());
+ return BcelWorld.fromBcel(t);
+ }
+ // A new array instruction obviously tells us it is an array type !
+ if (searchPtr.getInstruction().opcode == Constants.ANEWARRAY) {
+ // ANEWARRAY ana = (ANEWARRAY)searchPoint.getInstruction();
+ // Type t = ana.getType(getEnclosingClass().getConstantPool());
+ // Just use a standard java.lang.object array - that will work fine
+ return BcelWorld.fromBcel(new ArrayType(Type.OBJECT, 1));
+ }
+ // A multi new array instruction obviously tells us it is an array type !
+ if (searchPtr.getInstruction() instanceof MULTIANEWARRAY) {
+ MULTIANEWARRAY ana = (MULTIANEWARRAY) searchPtr.getInstruction();
+ // Type t = ana.getType(getEnclosingClass().getConstantPool());
+ // t = new ArrayType(t,ana.getDimensions());
+ // Just use a standard java.lang.object array - that will work fine
+ return BcelWorld.fromBcel(new ArrayType(Type.OBJECT, ana.getDimensions()));
+ }
+ throw new BCException("Can't determine real target of clone() when processing instruction "
+ + searchPtr.getInstruction() + ". Perhaps avoid selecting clone with your pointcut?");
+ }
+ return tx;
+ }
+
+ public void initializeArgVars() {
+ if (argVars != null)
+ return;
+ InstructionFactory fact = getFactory();
+ int len = getArgCount();
+ argVars = new BcelVar[len];
+ int positionOffset = (hasTarget() ? 1 : 0) + ((hasThis() && !getKind().isTargetSameAsThis()) ? 1 : 0);
+
+ if (getKind().argsOnStack()) {
+ // we move backwards because we're popping off the stack
+ for (int i = len - 1; i >= 0; i--) {
+ UnresolvedType type = getArgType(i);
+ BcelVar tmp = genTempVar(type, "ajc$arg" + i);
+ range.insert(tmp.createStore(getFactory()), Range.OutsideBefore);
+ int position = i;
+ position += positionOffset;
+ tmp.setPositionInAroundState(position);
+ argVars[i] = tmp;
+ }
+ } else {
+ int index = 0;
+ if (arg0HoldsThis())
+ index++;
+
+ for (int i = 0; i < len; i++) {
+ UnresolvedType type = getArgType(i);
+ BcelVar tmp = genTempVar(type, "ajc$arg" + i);
+ range.insert(tmp.createCopyFrom(fact, index), Range.OutsideBefore);
+ argVars[i] = tmp;
+ int position = i;
+ position += positionOffset;
+ // System.out.println("set position: " + tmp + ", " + position + " in " + this);
+ // System.out.println(" hasThis: " + hasThis() + ", hasTarget: " + hasTarget());
+ tmp.setPositionInAroundState(position);
+ index += type.getSize();
+ }
+ }
+ }
+
+ public void initializeForAroundClosure() {
+ initializeArgVars();
+ if (hasTarget())
+ initializeTargetVar();
+ if (hasThis())
+ initializeThisVar();
+ // System.out.println("initialized: " + this + " thisVar = " + thisVar);
+ }
+
+ public void initializeThisAnnotationVars() {
+ if (thisAnnotationVars != null)
+ return;
+ thisAnnotationVars = new HashMap();
+ // populate..
+ }
+
+ public void initializeTargetAnnotationVars() {
+ if (targetAnnotationVars != null)
+ return;
+ if (getKind().isTargetSameAsThis()) {
+ if (hasThis())
+ initializeThisAnnotationVars();
+ targetAnnotationVars = thisAnnotationVars;
+ } else {
+ targetAnnotationVars = new HashMap();
+ ResolvedType[] rtx = this.getTargetType().resolve(world).getAnnotationTypes(); // what about annotations we havent
+ // gotten yet but we will get in
+ // subclasses?
+ for (int i = 0; i < rtx.length; i++) {
+ ResolvedType typeX = rtx[i];
+ targetAnnotationVars.put(typeX, new TypeAnnotationAccessVar(typeX, (BcelVar) getTargetVar()));
+ }
+ // populate.
+ }
+ }
+
+ public void initializeArgAnnotationVars() {
+ if (argAnnotationVars != null)
+ return;
+ int numArgs = getArgCount();
+ argAnnotationVars = new Map[numArgs];
+ for (int i = 0; i < argAnnotationVars.length; i++) {
+ argAnnotationVars[i] = new HashMap();
+ // FIXME asc just delete this logic - we always build the Var on demand, as we don't know at weave time
+ // what the full set of annotations could be (due to static/dynamic type differences...)
+ }
+ }
+
+ protected ResolvedMember getRelevantMember(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType) {
+ if (foundMember != null) {
+ return foundMember;
+ }
+
+ foundMember = getSignature().resolve(world);
+ if (foundMember == null && relevantMember != null) {
+ foundMember = relevantType.lookupMemberWithSupersAndITDs(relevantMember);
+ }
+
+ // check the ITD'd dooberries
+ List mungers = relevantType.resolve(world).getInterTypeMungers();
+ for (Iterator iter = mungers.iterator(); iter.hasNext();) {
+ BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
+ if (typeMunger.getMunger() instanceof NewMethodTypeMunger || typeMunger.getMunger() instanceof NewConstructorTypeMunger) {
+ ResolvedMember fakerm = typeMunger.getSignature();
+ if (fakerm.getName().equals(getSignature().getName())
+ && fakerm.getParameterSignature().equals(getSignature().getParameterSignature())) {
+ if (foundMember.getKind() == ResolvedMember.CONSTRUCTOR) {
+ foundMember = AjcMemberMaker.interConstructor(relevantType, foundMember, typeMunger.getAspectType());
+ } else {
+ foundMember = AjcMemberMaker.interMethod(foundMember, typeMunger.getAspectType(), false);
+ }
+ // in the above.. what about if it's on an Interface? Can that happen?
+ // then the last arg of the above should be true
+ return foundMember;
+ }
+ }
+ }
+ return foundMember;
+ }
+
+ protected ResolvedType[] getAnnotations(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType) {
+ if (foundMember == null) {
+ // check the ITD'd dooberries
+ List mungers = relevantType.resolve(world).getInterTypeMungers();
+ for (Iterator iter = mungers.iterator(); iter.hasNext();) {
+ BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
+ if (typeMunger.getMunger() instanceof NewMethodTypeMunger
+ || typeMunger.getMunger() instanceof NewConstructorTypeMunger) {
+ ResolvedMember fakerm = typeMunger.getSignature();
+ // if (fakerm.hasAnnotations())
+
+ ResolvedMember ajcMethod = (getSignature().getKind() == ResolvedMember.CONSTRUCTOR ? AjcMemberMaker
+ .postIntroducedConstructor(typeMunger.getAspectType(), fakerm.getDeclaringType(), fakerm
+ .getParameterTypes()) : AjcMemberMaker
+ .interMethodDispatcher(fakerm, typeMunger.getAspectType()));
+ // AjcMemberMaker.interMethodBody(fakerm,typeMunger.getAspectType()));
+ ResolvedMember rmm = findMethod(typeMunger.getAspectType(), ajcMethod);
+ if (fakerm.getName().equals(getSignature().getName())
+ && fakerm.getParameterSignature().equals(getSignature().getParameterSignature())) {
+ relevantType = typeMunger.getAspectType();
+ foundMember = rmm;
+ return foundMember.getAnnotationTypes();
+ }
+ }
+ }
+ // didn't find in ITDs, look in supers
+ foundMember = relevantType.lookupMemberWithSupersAndITDs(relevantMember);
+ if (foundMember == null) {
+ throw new IllegalStateException("Couldn't find member " + relevantMember + " for type " + relevantType);
+ }
+ }
+ return foundMember.getAnnotationTypes();
+ }
+
+ /**
+ * By determining what "kind" of shadow we are, we can find out the annotations on the appropriate element (method, field,
+ * constructor, type). Then create one BcelVar entry in the map for each annotation, keyed by annotation type.
+ */
+ public void initializeKindedAnnotationVars() {
+ if (kindedAnnotationVars != null)
+ return;
+ kindedAnnotationVars = new HashMap();
+
+ // FIXME asc Refactor this code, there is duplication
+ ResolvedType[] annotations = null;
+ Member shadowSignature = getSignature();
+ Member annotationHolder = getSignature();
+ ResolvedType relevantType = shadowSignature.getDeclaringType().resolve(world);
+
+ if (relevantType.isRawType() || relevantType.isParameterizedType())
+ relevantType = relevantType.getGenericType();
+
+ if (getKind() == Shadow.StaticInitialization) {
+ annotations = relevantType.resolve(world).getAnnotationTypes();
+ } else if (getKind() == Shadow.MethodCall || getKind() == Shadow.ConstructorCall) {
+ ResolvedMember foundMember = findMethod2(relevantType.resolve(world).getDeclaredMethods(), getSignature());
+ annotations = getAnnotations(foundMember, shadowSignature, relevantType);
+ annotationHolder = getRelevantMember(foundMember, shadowSignature, relevantType);
+ relevantType = annotationHolder.getDeclaringType().resolve(world);
+
+ } else if (getKind() == Shadow.FieldSet || getKind() == Shadow.FieldGet) {
+ annotationHolder = findField(relevantType.getDeclaredFields(), getSignature());
+
+ if (annotationHolder == null) {
+ // check the ITD'd dooberries
+ List mungers = relevantType.resolve(world).getInterTypeMungers();
+ for (Iterator iter = mungers.iterator(); iter.hasNext();) {
+ BcelTypeMunger typeMunger = (BcelTypeMunger) iter.next();
+ if (typeMunger.getMunger() instanceof NewFieldTypeMunger) {
+ ResolvedMember fakerm = typeMunger.getSignature();
+ // if (fakerm.hasAnnotations())
+ ResolvedMember ajcMethod = AjcMemberMaker.interFieldInitializer(fakerm, typeMunger.getAspectType());
+ ResolvedMember rmm = findMethod(typeMunger.getAspectType(), ajcMethod);
+ if (fakerm.equals(getSignature())) {
+ relevantType = typeMunger.getAspectType();
+ annotationHolder = rmm;
+ }
+ }
+ }
+ }
+ annotations = ((ResolvedMember) annotationHolder).getAnnotationTypes();
+
+ } else if (getKind() == Shadow.MethodExecution || getKind() == Shadow.ConstructorExecution
+ || getKind() == Shadow.AdviceExecution) {
+ // ResolvedMember rm[] = relevantType.getDeclaredMethods();
+ ResolvedMember foundMember = findMethod2(relevantType.getDeclaredMethods(), getSignature());
+
+ annotations = getAnnotations(foundMember, shadowSignature, relevantType);
+ annotationHolder = foundMember;
+ annotationHolder = getRelevantMember(foundMember, annotationHolder, relevantType);
+
+ } else if (getKind() == Shadow.ExceptionHandler) {
+ relevantType = getSignature().getParameterTypes()[0].resolve(world);
+ annotations = relevantType.getAnnotationTypes();
+ } else if (getKind() == Shadow.PreInitialization || getKind() == Shadow.Initialization) {
+ ResolvedMember found = findMethod2(relevantType.getDeclaredMethods(), getSignature());
+ annotations = found.getAnnotationTypes();
+ }
+
+ if (annotations == null) {
+ // We can't have recognized the shadow - should blow up now to be on the safe side
+ throw new BCException("Could not discover annotations for shadow: " + getKind());
+ }
+
+ for (int i = 0; i < annotations.length; i++) {
+ ResolvedType annotationType = annotations[i];
+ AnnotationAccessVar accessVar = new AnnotationAccessVar(getKind(), annotationType.resolve(world), relevantType,
+ annotationHolder);
+ kindedAnnotationVars.put(annotationType, accessVar);
+ }
+ }
+
+ // FIXME asc whats the real diff between this one and the version in findMethod()?
+ ResolvedMember findMethod2(ResolvedMember rm[], Member sig) {
+ ResolvedMember found = null;
+ // String searchString = getSignature().getName()+getSignature().getParameterSignature();
+ for (int i = 0; i < rm.length && found == null; i++) {
+ ResolvedMember member = rm[i];
+ if (member.getName().equals(sig.getName()) && member.getParameterSignature().equals(sig.getParameterSignature()))
+ found = member;
+ }
+ return found;
+ }
+
+ private ResolvedMember findMethod(ResolvedType aspectType, ResolvedMember ajcMethod) {
+ ResolvedMember decMethods[] = aspectType.getDeclaredMethods();
+ for (int i = 0; i < decMethods.length; i++) {
+ ResolvedMember member = decMethods[i];
+ if (member.equals(ajcMethod))
+ return member;
+ }
+ return null;
+ }
+
+ private ResolvedMember findField(ResolvedMember[] members, Member lookingFor) {
+ for (int i = 0; i < members.length; i++) {
+ ResolvedMember member = members[i];
+ if (member.getName().equals(getSignature().getName()) && member.getType().equals(getSignature().getType())) {
+ return member;
+ }
+ }
+ return null;
+ }
+
+ public void initializeWithinAnnotationVars() {
+ if (withinAnnotationVars != null)
+ return;
+ withinAnnotationVars = new HashMap();
+
+ ResolvedType[] annotations = getEnclosingType().resolve(world).getAnnotationTypes();
+ for (int i = 0; i < annotations.length; i++) {
+ ResolvedType ann = annotations[i];
+ Kind k = Shadow.StaticInitialization;
+ withinAnnotationVars.put(ann, new AnnotationAccessVar(k, ann, getEnclosingType(), null));
+ }
+ }
+
+ public void initializeWithinCodeAnnotationVars() {
+ if (withincodeAnnotationVars != null)
+ return;
+ withincodeAnnotationVars = new HashMap();
+
+ // For some shadow we are interested in annotations on the method containing that shadow.
+ ResolvedType[] annotations = getEnclosingMethod().getMemberView().getAnnotationTypes();
+ for (int i = 0; i < annotations.length; i++) {
+ ResolvedType ann = annotations[i];
+ Kind k = (getEnclosingMethod().getMemberView().getKind() == Member.CONSTRUCTOR ? Shadow.ConstructorExecution
+ : Shadow.MethodExecution);
+ withincodeAnnotationVars.put(ann, new AnnotationAccessVar(k, ann, getEnclosingType(), getEnclosingCodeSignature()));
+ }
+ }
+
+ // ---- weave methods
+
+ void weaveBefore(BcelAdvice munger) {
+ range.insert(munger.getAdviceInstructions(this, null, range.getRealStart()), Range.InsideBefore);
+ }
+
+ public void weaveAfter(BcelAdvice munger) {
+ weaveAfterThrowing(munger, UnresolvedType.THROWABLE);
+ weaveAfterReturning(munger);
+ }
+
+ /**
+ * The basic strategy here is to add a set of instructions at the end of the shadow range that dispatch the advice, and then
+ * return whatever the shadow was going to return anyway.
+ *
+ * To achieve this, we note all the return statements in the advice, and replace them with code that: 1) stores the return value
+ * on top of the stack in a temp var 2) jumps to the start of our advice block 3) restores the return value at the end of the
+ * advice block before ultimately returning
+ *
+ * We also need to bind the return value into a returning parameter, if the advice specified one.
+ */
+ public void weaveAfterReturning(BcelAdvice munger) {
+ List returns = findReturnInstructions();
+ boolean hasReturnInstructions = !returns.isEmpty();
+
+ // list of instructions that handle the actual return from the join point
+ InstructionList retList = new InstructionList();
+
+ // variable that holds the return value
+ BcelVar returnValueVar = null;
+
+ if (hasReturnInstructions) {
+ returnValueVar = generateReturnInstructions(returns, retList);
+ } else {
+ // we need at least one instruction, as the target for jumps
+ retList.append(InstructionConstants.NOP);
+ }
+
+ // list of instructions for dispatching to the advice itself
+ InstructionList advice = getAfterReturningAdviceDispatchInstructions(munger, retList.getStart());
+
+ if (hasReturnInstructions) {
+ InstructionHandle gotoTarget = advice.getStart();
+ for (Iterator i = returns.iterator(); i.hasNext();) {
+ InstructionHandle ih = (InstructionHandle) i.next();
+ retargetReturnInstruction(munger.hasExtraParameter(), returnValueVar, gotoTarget, ih);
+ }
+ }
+
+ range.append(advice);
+ range.append(retList);
+ }
+
+ /**
+ * @return a list of all the return instructions in the range of this shadow
+ */
+ private List findReturnInstructions() {
List returns = new ArrayList();
- for (InstructionHandle ih = range.getStart(); ih != range.getEnd(); ih = ih.getNext()) {
- if (ih.getInstruction().isReturnInstruction()) {
- returns.add(ih);
- }
- }
+ for (InstructionHandle ih = range.getStart(); ih != range.getEnd(); ih = ih.getNext()) {
+ if (ih.getInstruction().isReturnInstruction()) {
+ returns.add(ih);
+ }
+ }
return returns;
}
/**
- * Given a list containing all the return instruction handles for this shadow,
- * finds the last return instruction and copies it, making this the ultimate
- * return. If the shadow has a non-void return type, we also create a temporary
- * variable to hold the return value, and load the value from this var before
- * returning (see pr148007 for why we do this - it works around a JRockit bug,
- * and is also closer to what javac generates)
+ * Given a list containing all the return instruction handles for this shadow, finds the last return instruction and copies it,
+ * making this the ultimate return. If the shadow has a non-void return type, we also create a temporary variable to hold the
+ * return value, and load the value from this var before returning (see pr148007 for why we do this - it works around a JRockit
+ * bug, and is also closer to what javac generates)
*
- * Sometimes the 'last return' isnt the right one - some rogue code can
- * include the real return from the body of a subroutine that exists at the end
- * of the method. In this case the last return is RETURN but that may not be
- * correct for a method with a non-void return type... pr151673
+ * Sometimes the 'last return' isnt the right one - some rogue code can include the real return from the body of a subroutine
+ * that exists at the end of the method. In this case the last return is RETURN but that may not be correct for a method with a
+ * non-void return type... pr151673
*
* @param returns list of all the return instructions in the shadow
- * @param returnInstructions instruction list into which the return instructions should
- * be generated
+ * @param returnInstructions instruction list into which the return instructions should be generated
* @return the variable holding the return value, if needed
*/
private BcelVar generateReturnInstructions(List returns, InstructionList returnInstructions) {
BcelVar returnValueVar = null;
- if (this.hasANonVoidReturnType()) {
- // Find the last *correct* return - this is a method with a non-void return type
- // so ignore RETURN
- Instruction newReturnInstruction = null;
- int i=returns.size()-1;
- while (newReturnInstruction == null && i>=0) {
- InstructionHandle ih = (InstructionHandle)returns.get(i);
- if (ih.getInstruction().opcode!=Constants.RETURN) {
- newReturnInstruction = Utility.copyInstruction(ih.getInstruction());
- }
- i--;
- }
- returnValueVar = genTempVar(this.getReturnType());
- returnValueVar.appendLoad(returnInstructions,getFactory());
- returnInstructions.append(newReturnInstruction);
- } else {
- InstructionHandle lastReturnHandle = (InstructionHandle)returns.get(returns.size() - 1);
- Instruction newReturnInstruction = Utility.copyInstruction(lastReturnHandle.getInstruction());
- returnInstructions.append(newReturnInstruction);
- }
- return returnValueVar;
- }
-
+ if (this.hasANonVoidReturnType()) {
+ // Find the last *correct* return - this is a method with a non-void return type
+ // so ignore RETURN
+ Instruction newReturnInstruction = null;
+ int i = returns.size() - 1;
+ while (newReturnInstruction == null && i >= 0) {
+ InstructionHandle ih = (InstructionHandle) returns.get(i);
+ if (ih.getInstruction().opcode != Constants.RETURN) {
+ newReturnInstruction = Utility.copyInstruction(ih.getInstruction());
+ }
+ i--;
+ }
+ returnValueVar = genTempVar(this.getReturnType());
+ returnValueVar.appendLoad(returnInstructions, getFactory());
+ returnInstructions.append(newReturnInstruction);
+ } else {
+ InstructionHandle lastReturnHandle = (InstructionHandle) returns.get(returns.size() - 1);
+ Instruction newReturnInstruction = Utility.copyInstruction(lastReturnHandle.getInstruction());
+ returnInstructions.append(newReturnInstruction);
+ }
+ return returnValueVar;
+ }
+
/**
* @return true, iff this shadow returns a value
*/
/**
* Get the list of instructions used to dispatch to the after advice
+ *
* @param munger
* @param firstInstructionInReturnSequence
* @return
*/
- private InstructionList getAfterReturningAdviceDispatchInstructions(BcelAdvice munger, InstructionHandle firstInstructionInReturnSequence) {
+ private InstructionList getAfterReturningAdviceDispatchInstructions(BcelAdvice munger,
+ InstructionHandle firstInstructionInReturnSequence) {
InstructionList advice = new InstructionList();
-
- BcelVar tempVar = null;
- if (munger.hasExtraParameter()) {
- tempVar = insertAdviceInstructionsForBindingReturningParameter(advice);
- }
- advice.append(munger.getAdviceInstructions(this, tempVar, firstInstructionInReturnSequence));
+
+ BcelVar tempVar = null;
+ if (munger.hasExtraParameter()) {
+ tempVar = insertAdviceInstructionsForBindingReturningParameter(advice);
+ }
+ advice.append(munger.getAdviceInstructions(this, tempVar, firstInstructionInReturnSequence));
return advice;
}
/**
- * If the after() returning(Foo f) form is used, bind the return value to the parameter.
- * If the shadow returns void, bind null.
+ * If the after() returning(Foo f) form is used, bind the return value to the parameter. If the shadow returns void, bind null.
+ *
* @param advice
* @return
*/
advice.append(InstructionConstants.ACONST_NULL);
tempVar.appendStore(advice, getFactory());
} else {
- tempVar = genTempVar(tempVarType);
- advice.append(InstructionFactory.createDup(tempVarType.getSize()));
- tempVar.appendStore(advice, getFactory());
+ tempVar = genTempVar(tempVarType);
+ advice.append(InstructionFactory.createDup(tempVarType.getSize()));
+ tempVar.appendStore(advice, getFactory());
}
return tempVar;
}
-
/**
* Helper method for weaveAfterReturning
*
- * Each return instruction in the method body is retargeted by calling this method.
- * The return instruction is replaced by up to three instructions:
- * 1) if the shadow returns a value, and that value is bound to an after returning
- * parameter, then we DUP the return value on the top of the stack
- * 2) if the shadow returns a value, we store it in the returnValueVar (it will
- * be retrieved from here when we ultimately return after the advice dispatch)
- * 3) if the return was the last instruction, we add a NOP (it will fall through
- * to the advice dispatch), otherwise we add a GOTO that branches to the
- * supplied gotoTarget (start of the advice dispatch)
+ * Each return instruction in the method body is retargeted by calling this method. The return instruction is replaced by up to
+ * three instructions: 1) if the shadow returns a value, and that value is bound to an after returning parameter, then we DUP
+ * the return value on the top of the stack 2) if the shadow returns a value, we store it in the returnValueVar (it will be
+ * retrieved from here when we ultimately return after the advice dispatch) 3) if the return was the last instruction, we add a
+ * NOP (it will fall through to the advice dispatch), otherwise we add a GOTO that branches to the supplied gotoTarget (start of
+ * the advice dispatch)
*/
- private void retargetReturnInstruction(boolean hasReturningParameter, BcelVar returnValueVar, InstructionHandle gotoTarget, InstructionHandle returnHandle) {
+ private void retargetReturnInstruction(boolean hasReturningParameter, BcelVar returnValueVar, InstructionHandle gotoTarget,
+ InstructionHandle returnHandle) {
// pr148007, work around JRockit bug
// replace ret with store into returnValueVar, followed by goto if not
// at the end of the instruction list...
InstructionList newInstructions = new InstructionList();
if (returnValueVar != null) {
- if (hasReturningParameter) {
- // we have to dup the return val before consuming it...
- newInstructions.append(InstructionFactory.createDup(this.getReturnType().getSize()));
- }
+ if (hasReturningParameter) {
+ // we have to dup the return val before consuming it...
+ newInstructions.append(InstructionFactory.createDup(this.getReturnType().getSize()));
+ }
// store the return value into this var
- returnValueVar.appendStore(newInstructions,getFactory());
+ returnValueVar.appendStore(newInstructions, getFactory());
}
- if (!isLastInstructionInRange(returnHandle,range)) {
- newInstructions.append(InstructionFactory.createBranchInstruction(
- Constants.GOTO,
- gotoTarget));
+ if (!isLastInstructionInRange(returnHandle, range)) {
+ newInstructions.append(InstructionFactory.createBranchInstruction(Constants.GOTO, gotoTarget));
}
if (newInstructions.isEmpty()) {
newInstructions.append(InstructionConstants.NOP);
}
- Utility.replaceInstruction(returnHandle,newInstructions,enclosingMethod);
- }
-
- private boolean isLastInstructionInRange(InstructionHandle ih, ShadowRange aRange) {
- return ih.getNext() == aRange.getEnd();
- }
-
- public void weaveAfterThrowing(BcelAdvice munger, UnresolvedType catchType) {
- // a good optimization would be not to generate anything here
- // if the shadow is GUARANTEED empty (i.e., there's NOTHING, not even
- // a shadow, inside me).
- if (getRange().getStart().getNext() == getRange().getEnd()) return;
- InstructionFactory fact = getFactory();
- InstructionList handler = new InstructionList();
- BcelVar exceptionVar = genTempVar(catchType);
- exceptionVar.appendStore(handler, fact);
-
- // pr62642
- // I will now jump through some firey BCEL hoops to generate a trivial bit of code:
- // if (exc instanceof ExceptionInInitializerError)
- // throw (ExceptionInInitializerError)exc;
- if (this.getEnclosingMethod().getName().equals("<clinit>")) {
- ResolvedType eiieType = world.resolve("java.lang.ExceptionInInitializerError");
- ObjectType eiieBcelType = (ObjectType)BcelWorld.makeBcelType(eiieType);
- InstructionList ih = new InstructionList(InstructionConstants.NOP);
- handler.append(exceptionVar.createLoad(fact));
- handler.append(fact.createInstanceOf(eiieBcelType));
- InstructionBranch bi =
- InstructionFactory.createBranchInstruction(Constants.IFEQ,ih.getStart());
- handler.append(bi);
- handler.append(exceptionVar.createLoad(fact));
- handler.append(fact.createCheckCast(eiieBcelType));
- handler.append(InstructionConstants.ATHROW);
- handler.append(ih);
- }
-
- InstructionList endHandler = new InstructionList(
- exceptionVar.createLoad(fact));
- handler.append(munger.getAdviceInstructions(this, exceptionVar, endHandler.getStart()));
- handler.append(endHandler);
- handler.append(InstructionConstants.ATHROW);
- InstructionHandle handlerStart = handler.getStart();
-
- if (isFallsThrough()) {
- InstructionHandle jumpTarget = handler.append(InstructionConstants.NOP);
- handler.insert(InstructionFactory.createBranchInstruction(Constants.GOTO, jumpTarget));
- }
+ Utility.replaceInstruction(returnHandle, newInstructions, enclosingMethod);
+ }
+
+ private boolean isLastInstructionInRange(InstructionHandle ih, ShadowRange aRange) {
+ return ih.getNext() == aRange.getEnd();
+ }
+
+ public void weaveAfterThrowing(BcelAdvice munger, UnresolvedType catchType) {
+ // a good optimization would be not to generate anything here
+ // if the shadow is GUARANTEED empty (i.e., there's NOTHING, not even
+ // a shadow, inside me).
+ if (getRange().getStart().getNext() == getRange().getEnd())
+ return;
+ InstructionFactory fact = getFactory();
+ InstructionList handler = new InstructionList();
+ BcelVar exceptionVar = genTempVar(catchType);
+ exceptionVar.appendStore(handler, fact);
+
+ // pr62642
+ // I will now jump through some firey BCEL hoops to generate a trivial bit of code:
+ // if (exc instanceof ExceptionInInitializerError)
+ // throw (ExceptionInInitializerError)exc;
+ if (this.getEnclosingMethod().getName().equals("<clinit>")) {
+ ResolvedType eiieType = world.resolve("java.lang.ExceptionInInitializerError");
+ ObjectType eiieBcelType = (ObjectType) BcelWorld.makeBcelType(eiieType);
+ InstructionList ih = new InstructionList(InstructionConstants.NOP);
+ handler.append(exceptionVar.createLoad(fact));
+ handler.append(fact.createInstanceOf(eiieBcelType));
+ InstructionBranch bi = InstructionFactory.createBranchInstruction(Constants.IFEQ, ih.getStart());
+ handler.append(bi);
+ handler.append(exceptionVar.createLoad(fact));
+ handler.append(fact.createCheckCast(eiieBcelType));
+ handler.append(InstructionConstants.ATHROW);
+ handler.append(ih);
+ }
+
+ InstructionList endHandler = new InstructionList(exceptionVar.createLoad(fact));
+ handler.append(munger.getAdviceInstructions(this, exceptionVar, endHandler.getStart()));
+ handler.append(endHandler);
+ handler.append(InstructionConstants.ATHROW);
+ InstructionHandle handlerStart = handler.getStart();
+
+ if (isFallsThrough()) {
+ InstructionHandle jumpTarget = handler.append(InstructionConstants.NOP);
+ handler.insert(InstructionFactory.createBranchInstruction(Constants.GOTO, jumpTarget));
+ }
InstructionHandle protectedEnd = handler.getStart();
- range.insert(handler, Range.InsideAfter);
-
- enclosingMethod.addExceptionHandler(range.getStart().getNext(), protectedEnd.getPrev(),
- handlerStart, (ObjectType)BcelWorld.makeBcelType(catchType), //???Type.THROWABLE,
- // high priority if our args are on the stack
- getKind().hasHighPriorityExceptions());
- }
-
-
- //??? this shares a lot of code with the above weaveAfterThrowing
- //??? would be nice to abstract that to say things only once
- public void weaveSoftener(BcelAdvice munger, UnresolvedType catchType) {
- // a good optimization would be not to generate anything here
- // if the shadow is GUARANTEED empty (i.e., there's NOTHING, not even
- // a shadow, inside me).
- if (getRange().getStart().getNext() == getRange().getEnd()) return;
-
- InstructionFactory fact = getFactory();
- InstructionList handler = new InstructionList();
+ range.insert(handler, Range.InsideAfter);
+
+ enclosingMethod.addExceptionHandler(range.getStart().getNext(), protectedEnd.getPrev(), handlerStart,
+ (ObjectType) BcelWorld.makeBcelType(catchType), // ???Type.THROWABLE,
+ // high priority if our args are on the stack
+ getKind().hasHighPriorityExceptions());
+ }
+
+ // ??? this shares a lot of code with the above weaveAfterThrowing
+ // ??? would be nice to abstract that to say things only once
+ public void weaveSoftener(BcelAdvice munger, UnresolvedType catchType) {
+ // a good optimization would be not to generate anything here
+ // if the shadow is GUARANTEED empty (i.e., there's NOTHING, not even
+ // a shadow, inside me).
+ if (getRange().getStart().getNext() == getRange().getEnd())
+ return;
+
+ InstructionFactory fact = getFactory();
+ InstructionList handler = new InstructionList();
InstructionList rtExHandler = new InstructionList();
- BcelVar exceptionVar = genTempVar(catchType);
-
+ BcelVar exceptionVar = genTempVar(catchType);
+
handler.append(fact.createNew(NameMangler.SOFT_EXCEPTION_TYPE));
- handler.append(InstructionFactory.createDup(1));
- handler.append(exceptionVar.createLoad(fact));
- handler.append(fact.createInvoke(NameMangler.SOFT_EXCEPTION_TYPE, "<init>",
- Type.VOID, new Type[] { Type.THROWABLE }, Constants.INVOKESPECIAL)); //??? special
- handler.append(InstructionConstants.ATHROW);
+ handler.append(InstructionFactory.createDup(1));
+ handler.append(exceptionVar.createLoad(fact));
+ handler.append(fact.createInvoke(NameMangler.SOFT_EXCEPTION_TYPE, "<init>", Type.VOID, new Type[] { Type.THROWABLE },
+ Constants.INVOKESPECIAL)); // ??? special
+ handler.append(InstructionConstants.ATHROW);
// ENH 42737
- exceptionVar.appendStore(rtExHandler, fact);
+ exceptionVar.appendStore(rtExHandler, fact);
// aload_1
rtExHandler.append(exceptionVar.createLoad(fact));
// instanceof class java/lang/RuntimeException
rtExHandler.append(fact.createInstanceOf(new ObjectType("java.lang.RuntimeException")));
// ifeq go to new SOFT_EXCEPTION_TYPE instruction
- rtExHandler.append(InstructionFactory.createBranchInstruction(Constants.IFEQ,handler.getStart()));
+ rtExHandler.append(InstructionFactory.createBranchInstruction(Constants.IFEQ, handler.getStart()));
// aload_1
rtExHandler.append(exceptionVar.createLoad(fact));
// athrow
InstructionHandle handlerStart = rtExHandler.getStart();
if (isFallsThrough()) {
- InstructionHandle jumpTarget = range.getEnd();//handler.append(fact.NOP);
- rtExHandler.insert(InstructionFactory.createBranchInstruction(Constants.GOTO, jumpTarget));
- }
+ InstructionHandle jumpTarget = range.getEnd();// handler.append(fact.NOP);
+ rtExHandler.insert(InstructionFactory.createBranchInstruction(Constants.GOTO, jumpTarget));
+ }
rtExHandler.append(handler);
InstructionHandle protectedEnd = rtExHandler.getStart();
- range.insert(rtExHandler, Range.InsideAfter);
-
- enclosingMethod.addExceptionHandler(range.getStart().getNext(), protectedEnd.getPrev(),
- handlerStart, (ObjectType)BcelWorld.makeBcelType(catchType),
- // high priority if our args are on the stack
- getKind().hasHighPriorityExceptions());
- }
+ range.insert(rtExHandler, Range.InsideAfter);
+ enclosingMethod.addExceptionHandler(range.getStart().getNext(), protectedEnd.getPrev(), handlerStart,
+ (ObjectType) BcelWorld.makeBcelType(catchType),
+ // high priority if our args are on the stack
+ getKind().hasHighPriorityExceptions());
+ }
public void weavePerObjectEntry(final BcelAdvice munger, final BcelVar onVar) {
- final InstructionFactory fact = getFactory();
-
+ final InstructionFactory fact = getFactory();
InstructionList entryInstructions = new InstructionList();
InstructionList entrySuccessInstructions = new InstructionList();
onVar.appendLoad(entrySuccessInstructions, fact);
- entrySuccessInstructions.append(
- Utility.createInvoke(fact, world,
- AjcMemberMaker.perObjectBind(munger.getConcreteAspect())));
-
- InstructionList testInstructions =
- munger.getTestInstructions(this, entrySuccessInstructions.getStart(),
- range.getRealStart(),
- entrySuccessInstructions.getStart());
-
+ entrySuccessInstructions
+ .append(Utility.createInvoke(fact, world, AjcMemberMaker.perObjectBind(munger.getConcreteAspect())));
+
+ InstructionList testInstructions = munger.getTestInstructions(this, entrySuccessInstructions.getStart(), range
+ .getRealStart(), entrySuccessInstructions.getStart());
+
entryInstructions.append(testInstructions);
entryInstructions.append(entrySuccessInstructions);
-
+
range.insert(entryInstructions, Range.InsideBefore);
}
-
- // PTWIMPL Create static initializer to call the aspect factory
+
+ // PTWIMPL Create static initializer to call the aspect factory
/**
* Causes the aspect instance to be *set* for later retrievable through localAspectof()/aspectOf()
*/
- public void weavePerTypeWithinAspectInitialization(final BcelAdvice munger,UnresolvedType t) {
-
- if (t.resolve(world).isInterface()) return; // Don't initialize statics in
- final InstructionFactory fact = getFactory();
+ public void weavePerTypeWithinAspectInitialization(final BcelAdvice munger, UnresolvedType t) {
+
+ if (t.resolve(world).isInterface())
+ return; // Don't initialize statics in
+ final InstructionFactory fact = getFactory();
InstructionList entryInstructions = new InstructionList();
InstructionList entrySuccessInstructions = new InstructionList();
-
+
BcelWorld.getBcelObjectType(munger.getConcreteAspect());
String aspectname = munger.getConcreteAspect().getName();
-
+
String ptwField = NameMangler.perTypeWithinFieldForTarget(munger.getConcreteAspect());
- entrySuccessInstructions.append(InstructionFactory.PUSH(fact.getConstantPool(),t.getName()));
-
- entrySuccessInstructions.append(fact.createInvoke(aspectname,"ajc$createAspectInstance",new ObjectType(aspectname),
- new Type[]{new ObjectType("java.lang.String")},Constants.INVOKESTATIC));
- entrySuccessInstructions.append(fact.createPutStatic(t.getName(),ptwField,
- new ObjectType(aspectname)));
-
+ entrySuccessInstructions.append(InstructionFactory.PUSH(fact.getConstantPool(), t.getName()));
+
+ entrySuccessInstructions.append(fact.createInvoke(aspectname, "ajc$createAspectInstance", new ObjectType(aspectname),
+ new Type[] { new ObjectType("java.lang.String") }, Constants.INVOKESTATIC));
+ entrySuccessInstructions.append(fact.createPutStatic(t.getName(), ptwField, new ObjectType(aspectname)));
+
entryInstructions.append(entrySuccessInstructions);
-
+
range.insert(entryInstructions, Range.InsideBefore);
}
-
-
+
public void weaveCflowEntry(final BcelAdvice munger, final Member cflowField) {
- final boolean isPer = munger.getKind() == AdviceKind.PerCflowBelowEntry ||
- munger.getKind() == AdviceKind.PerCflowEntry;
-
+ final boolean isPer = munger.getKind() == AdviceKind.PerCflowBelowEntry || munger.getKind() == AdviceKind.PerCflowEntry;
+
final Type objectArrayType = new ArrayType(Type.OBJECT, 1);
- final InstructionFactory fact = getFactory();
+ final InstructionFactory fact = getFactory();
final BcelVar testResult = genTempVar(ResolvedType.BOOLEAN);
InstructionList entryInstructions = new InstructionList();
{
InstructionList entrySuccessInstructions = new InstructionList();
-
+
if (munger.hasDynamicTests()) {
entryInstructions.append(Utility.createConstant(fact, 0));
testResult.appendStore(entryInstructions, fact);
-
+
entrySuccessInstructions.append(Utility.createConstant(fact, 1));
testResult.appendStore(entrySuccessInstructions, fact);
}
if (isPer) {
- entrySuccessInstructions.append(
- fact.createInvoke(munger.getConcreteAspect().getName(),
- NameMangler.PERCFLOW_PUSH_METHOD,
- Type.VOID,
- new Type[] { },
- Constants.INVOKESTATIC));
+ entrySuccessInstructions.append(fact.createInvoke(munger.getConcreteAspect().getName(),
+ NameMangler.PERCFLOW_PUSH_METHOD, Type.VOID, new Type[] {}, Constants.INVOKESTATIC));
} else {
BcelVar[] cflowStateVars = munger.getExposedStateAsBcelVars(false);
-
+
if (cflowStateVars.length == 0) {
// This should be getting managed by a counter - lets make sure.
- if (!cflowField.getType().getName().endsWith("CFlowCounter"))
+ if (!cflowField.getType().getName().endsWith("CFlowCounter"))
throw new RuntimeException("Incorrectly attempting counter operation on stacked cflow");
- entrySuccessInstructions.append(
- Utility.createGet(fact, cflowField));
- //arrayVar.appendLoad(entrySuccessInstructions, fact);
- entrySuccessInstructions.append(fact.createInvoke(NameMangler.CFLOW_COUNTER_TYPE,"inc",Type.VOID,new Type[] { },Constants.INVOKEVIRTUAL));
+ entrySuccessInstructions.append(Utility.createGet(fact, cflowField));
+ // arrayVar.appendLoad(entrySuccessInstructions, fact);
+ entrySuccessInstructions.append(fact.createInvoke(NameMangler.CFLOW_COUNTER_TYPE, "inc", Type.VOID,
+ new Type[] {}, Constants.INVOKEVIRTUAL));
} else {
- BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
-
- int alen = cflowStateVars.length;
- entrySuccessInstructions.append(Utility.createConstant(fact, alen));
- entrySuccessInstructions.append(fact.createNewArray(Type.OBJECT, (short) 1));
- arrayVar.appendStore(entrySuccessInstructions, fact);
-
- for (int i = 0; i < alen; i++) {
- arrayVar.appendConvertableArrayStore(
- entrySuccessInstructions,
- fact,
- i,
- cflowStateVars[i]);
- }
-
- entrySuccessInstructions.append(
- Utility.createGet(fact, cflowField));
- arrayVar.appendLoad(entrySuccessInstructions, fact);
-
- entrySuccessInstructions.append(
- fact.createInvoke(NameMangler.CFLOW_STACK_TYPE, "push", Type.VOID,
- new Type[] { objectArrayType },
- Constants.INVOKEVIRTUAL));
+ BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
+
+ int alen = cflowStateVars.length;
+ entrySuccessInstructions.append(Utility.createConstant(fact, alen));
+ entrySuccessInstructions.append(fact.createNewArray(Type.OBJECT, (short) 1));
+ arrayVar.appendStore(entrySuccessInstructions, fact);
+
+ for (int i = 0; i < alen; i++) {
+ arrayVar.appendConvertableArrayStore(entrySuccessInstructions, fact, i, cflowStateVars[i]);
+ }
+
+ entrySuccessInstructions.append(Utility.createGet(fact, cflowField));
+ arrayVar.appendLoad(entrySuccessInstructions, fact);
+
+ entrySuccessInstructions.append(fact.createInvoke(NameMangler.CFLOW_STACK_TYPE, "push", Type.VOID,
+ new Type[] { objectArrayType }, Constants.INVOKEVIRTUAL));
}
}
-
- InstructionList testInstructions =
- munger.getTestInstructions(this, entrySuccessInstructions.getStart(),
- range.getRealStart(),
- entrySuccessInstructions.getStart());
+ InstructionList testInstructions = munger.getTestInstructions(this, entrySuccessInstructions.getStart(), range
+ .getRealStart(), entrySuccessInstructions.getStart());
entryInstructions.append(testInstructions);
entryInstructions.append(entrySuccessInstructions);
}
-
+
// this is the same for both per and non-per
weaveAfter(new BcelAdvice(null, null, null, 0, 0, 0, null, null) {
- public InstructionList getAdviceInstructions(
- BcelShadow s,
- BcelVar extraArgVar,
- InstructionHandle ifNoAdvice) {
+ public InstructionList getAdviceInstructions(BcelShadow s, BcelVar extraArgVar, InstructionHandle ifNoAdvice) {
InstructionList exitInstructions = new InstructionList();
if (munger.hasDynamicTests()) {
testResult.appendLoad(exitInstructions, fact);
- exitInstructions.append(
- InstructionFactory.createBranchInstruction(
- Constants.IFEQ,
- ifNoAdvice));
+ exitInstructions.append(InstructionFactory.createBranchInstruction(Constants.IFEQ, ifNoAdvice));
}
exitInstructions.append(Utility.createGet(fact, cflowField));
- if (munger.getKind() != AdviceKind.PerCflowEntry &&
- munger.getKind() != AdviceKind.PerCflowBelowEntry &&
- munger.getExposedStateAsBcelVars(false).length==0) {
- exitInstructions
- .append(
- fact
- .createInvoke(
- NameMangler.CFLOW_COUNTER_TYPE,
- "dec",
- Type.VOID,
- new Type[] {
- }, Constants.INVOKEVIRTUAL));
+ if (munger.getKind() != AdviceKind.PerCflowEntry && munger.getKind() != AdviceKind.PerCflowBelowEntry
+ && munger.getExposedStateAsBcelVars(false).length == 0) {
+ exitInstructions.append(fact.createInvoke(NameMangler.CFLOW_COUNTER_TYPE, "dec", Type.VOID, new Type[] {},
+ Constants.INVOKEVIRTUAL));
} else {
- exitInstructions
- .append(
- fact
- .createInvoke(
- NameMangler.CFLOW_STACK_TYPE,
- "pop",
- Type.VOID,
- new Type[] {
- }, Constants.INVOKEVIRTUAL));
+ exitInstructions.append(fact.createInvoke(NameMangler.CFLOW_STACK_TYPE, "pop", Type.VOID, new Type[] {},
+ Constants.INVOKEVIRTUAL));
}
return exitInstructions;
}
});
-
-
+
range.insert(entryInstructions, Range.InsideBefore);
}
-
- /* Implementation notes:
- *
- * AroundInline still extracts the instructions of the original shadow into
- * an extracted method. This allows inlining of even that advice that doesn't
- * call proceed or calls proceed more than once.
- *
- * It extracts the instructions of the original shadow into a method.
- *
- * Then it extracts the instructions of the advice into a new method defined on
- * this enclosing class. This new method can then be specialized as below.
- *
- * Then it searches in the instructions of the advice for any call to the
- * proceed method.
- *
- * At such a call, there is stuff on the stack representing the arguments to
- * proceed. Pop these into the frame.
- *
- * Now build the stack for the call to the extracted method, taking values
- * either from the join point state or from the new frame locs from proceed.
- * Now call the extracted method. The right return value should be on the
- * stack, so no cast is necessary.
- *
- * If only one call to proceed is made, we can re-inline the original shadow.
- * We are not doing that presently.
- *
- * If the body of the advice can be determined to not alter the stack, or if
- * this shadow doesn't care about the stack, i.e. method-execution, then the
- * new method for the advice can also be re-lined. We are not doing that
- * presently.
- */
- public void weaveAroundInline(BcelAdvice munger,boolean hasDynamicTest) {
-
+
+ /*
+ * Implementation notes:
+ *
+ * AroundInline still extracts the instructions of the original shadow into an extracted method. This allows inlining of even
+ * that advice that doesn't call proceed or calls proceed more than once.
+ *
+ * It extracts the instructions of the original shadow into a method.
+ *
+ * Then it extracts the instructions of the advice into a new method defined on this enclosing class. This new method can then
+ * be specialized as below.
+ *
+ * Then it searches in the instructions of the advice for any call to the proceed method.
+ *
+ * At such a call, there is stuff on the stack representing the arguments to proceed. Pop these into the frame.
+ *
+ * Now build the stack for the call to the extracted method, taking values either from the join point state or from the new
+ * frame locs from proceed. Now call the extracted method. The right return value should be on the stack, so no cast is
+ * necessary.
+ *
+ * If only one call to proceed is made, we can re-inline the original shadow. We are not doing that presently.
+ *
+ * If the body of the advice can be determined to not alter the stack, or if this shadow doesn't care about the stack, i.e.
+ * method-execution, then the new method for the advice can also be re-lined. We are not doing that presently.
+ */
+ public void weaveAroundInline(BcelAdvice munger, boolean hasDynamicTest) {
+
// !!! THIS BLOCK OF CODE SHOULD BE IN A METHOD CALLED weaveAround(...);
- Member mungerSig = munger.getSignature();
- //Member originalSig = mungerSig; // If mungerSig is on a parameterized type, originalSig is the member on the generic type
- if (mungerSig instanceof ResolvedMember) {
- ResolvedMember rm = (ResolvedMember)mungerSig;
- if (rm.hasBackingGenericMember()) mungerSig = rm.getBackingGenericMember();
- }
- ResolvedType declaringType = world.resolve(mungerSig.getDeclaringType(),true);
- if (declaringType.isMissing()) {
- world.getLint().cantFindType.signal(
- new String[] {WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE,declaringType.getClassName())},
- getSourceLocation(),
- new ISourceLocation[]{ munger.getSourceLocation()}
- );
-// IMessage msg = new Message(
-// WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE,declaringType.getClassName()),
-// "",IMessage.ERROR,getSourceLocation(),null,
-// new ISourceLocation[]{ munger.getSourceLocation()});
-// world.getMessageHandler().handleMessage(msg);
- }
- //??? might want some checks here to give better errors
- ResolvedType rt = (declaringType.isParameterizedType()?declaringType.getGenericType():declaringType);
- BcelObjectType ot = BcelWorld.getBcelObjectType(rt);
-// if (ot==null) {
-// world.getMessageHandler().handleMessage(
-// MessageUtil.warn("Unable to find modifiable delegate for the aspect '"+rt.getName()+"' containing around advice - cannot implement inlining",munger.getSourceLocation()));
-// weaveAroundClosure(munger, hasDynamicTest);
-// return;
-// }
+ Member mungerSig = munger.getSignature();
+ // Member originalSig = mungerSig; // If mungerSig is on a parameterized type, originalSig is the member on the generic type
+ if (mungerSig instanceof ResolvedMember) {
+ ResolvedMember rm = (ResolvedMember) mungerSig;
+ if (rm.hasBackingGenericMember())
+ mungerSig = rm.getBackingGenericMember();
+ }
+ ResolvedType declaringType = world.resolve(mungerSig.getDeclaringType(), true);
+ if (declaringType.isMissing()) {
+ world.getLint().cantFindType.signal(new String[] { WeaverMessages.format(
+ WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE, declaringType.getClassName()) }, getSourceLocation(),
+ new ISourceLocation[] { munger.getSourceLocation() });
+ // IMessage msg = new Message(
+ // WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE,declaringType.getClassName()),
+ // "",IMessage.ERROR,getSourceLocation(),null,
+ // new ISourceLocation[]{ munger.getSourceLocation()});
+ // world.getMessageHandler().handleMessage(msg);
+ }
+ // ??? might want some checks here to give better errors
+ ResolvedType rt = (declaringType.isParameterizedType() ? declaringType.getGenericType() : declaringType);
+ BcelObjectType ot = BcelWorld.getBcelObjectType(rt);
+ // if (ot==null) {
+ // world.getMessageHandler().handleMessage(
+ // MessageUtil.warn("Unable to find modifiable delegate for the aspect '"+rt.getName()+
+ // "' containing around advice - cannot implement inlining",munger.getSourceLocation()));
+ // weaveAroundClosure(munger, hasDynamicTest);
+ // return;
+ // }
LazyMethodGen adviceMethod = ot.getLazyClassGen().getLazyMethodGen(mungerSig);
if (!adviceMethod.getCanInline()) {
weaveAroundClosure(munger, hasDynamicTest);
return;
}
- // specific test for @AJ proceedInInners
- if (munger.getConcreteAspect().isAnnotationStyleAspect()) {
- // if we can't find one proceed() we suspect that the call
- // is happening in an inner class so we don't inline it.
- // Note: for code style, this is done at Aspect compilation time.
- boolean canSeeProceedPassedToOther = false;
- InstructionHandle curr = adviceMethod.getBody().getStart();
- InstructionHandle end = adviceMethod.getBody().getEnd();
- ConstantPool cpg = adviceMethod.getEnclosingClass().getConstantPool();
- while (curr != end) {
- InstructionHandle next = curr.getNext();
- Instruction inst = curr.getInstruction();
- if ((inst instanceof InvokeInstruction)
- && ((InvokeInstruction)inst).getSignature(cpg).indexOf("Lorg/aspectj/lang/ProceedingJoinPoint;") > 0) {
- // we may want to refine to exclude stuff returning jp ?
- // does code style skip inline if i write dump(thisJoinPoint) ?
- canSeeProceedPassedToOther = true;// we see one pjp passed around - dangerous
- break;
- }
- curr = next;
- }
- if (canSeeProceedPassedToOther) {
- // remember this decision to avoid re-analysis
- adviceMethod.setCanInline(false);
- weaveAroundClosure(munger, hasDynamicTest);
- return;
- }
- }
-
-
+ // specific test for @AJ proceedInInners
+ if (munger.getConcreteAspect().isAnnotationStyleAspect()) {
+ // if we can't find one proceed() we suspect that the call
+ // is happening in an inner class so we don't inline it.
+ // Note: for code style, this is done at Aspect compilation time.
+ boolean canSeeProceedPassedToOther = false;
+ InstructionHandle curr = adviceMethod.getBody().getStart();
+ InstructionHandle end = adviceMethod.getBody().getEnd();
+ ConstantPool cpg = adviceMethod.getEnclosingClass().getConstantPool();
+ while (curr != end) {
+ InstructionHandle next = curr.getNext();
+ Instruction inst = curr.getInstruction();
+ if ((inst instanceof InvokeInstruction)
+ && ((InvokeInstruction) inst).getSignature(cpg).indexOf("Lorg/aspectj/lang/ProceedingJoinPoint;") > 0) {
+ // we may want to refine to exclude stuff returning jp ?
+ // does code style skip inline if i write dump(thisJoinPoint) ?
+ canSeeProceedPassedToOther = true;// we see one pjp passed around - dangerous
+ break;
+ }
+ curr = next;
+ }
+ if (canSeeProceedPassedToOther) {
+ // remember this decision to avoid re-analysis
+ adviceMethod.setCanInline(false);
+ weaveAroundClosure(munger, hasDynamicTest);
+ return;
+ }
+ }
// We can't inline around methods if they have around advice on them, this
// is because the weaving will extract the body and hence the proceed call.
- //??? should consider optimizations to recognize simple cases that don't require body extraction
+ // ??? should consider optimizations to recognize simple cases that don't require body extraction
enclosingMethod.setCanInline(false);
-
+
// start by exposing various useful things into the frame
final InstructionFactory fact = getFactory();
-
+
// now generate the aroundBody method
// eg. "private static final void method_aroundBody0(M, M, String, org.aspectj.lang.JoinPoint)"
- LazyMethodGen extractedMethod =
- extractMethod(
- NameMangler.aroundCallbackMethodName(getSignature(),getEnclosingClass()),
- Modifier.PRIVATE,
- munger);
-
- // now extract the advice into its own method
- String adviceMethodName =
- NameMangler.aroundCallbackMethodName(getSignature(),getEnclosingClass()) + "$advice";
-
- List argVarList = new ArrayList();
- List proceedVarList = new ArrayList();
+ LazyMethodGen extractedMethod = extractMethod(NameMangler.aroundCallbackMethodName(getSignature(), getEnclosingClass()),
+ Modifier.PRIVATE, munger);
+
+ // now extract the advice into its own method
+ String adviceMethodName = NameMangler.aroundCallbackMethodName(getSignature(), getEnclosingClass()) + "$advice";
+
+ List argVarList = new ArrayList();
+ List proceedVarList = new ArrayList();
int extraParamOffset = 0;
-
+
// Create the extra parameters that are needed for passing to proceed
// This code is very similar to that found in makeCallToCallback and should
// be rationalized in the future
-
+
if (thisVar != null) {
argVarList.add(thisVar);
proceedVarList.add(new BcelVar(thisVar.getType(), extraParamOffset));
extraParamOffset += thisVar.getType().getSize();
}
-
+
if (targetVar != null && targetVar != thisVar) {
argVarList.add(targetVar);
proceedVarList.add(new BcelVar(targetVar.getType(), extraParamOffset));
proceedVarList.add(new BcelVar(thisJoinPointVar.getType(), extraParamOffset));
extraParamOffset += thisJoinPointVar.getType().getSize();
}
-
+
// We use the munger signature here because it allows for any parameterization of the mungers pointcut that
// may have occurred ie. if the pointcut is p(T t) in the super aspect and that has become p(Foo t) in the sub aspect
- // then here the munger signature will have 'Foo' as an argument in it whilst the adviceMethod argument type will be 'Object' - since
- // it represents the advice method in the superaspect which uses the erasure of the type variable p(Object t) - see pr174449.
-
- Type[] adviceParameterTypes =
- BcelWorld.makeBcelTypes(munger.getSignature().getParameterTypes());
-// adviceMethod.getArgumentTypes();
- adviceMethod.getArgumentTypes(); // forces initialization ... dont like this but seems to be required for some tests to pass, I think that means
- // there is a LazyMethodGen method that is not correctly setup to call initialize() when it is invoked - but I dont have
- // time right now to discover which
- Type[] extractedMethodParameterTypes = extractedMethod.getArgumentTypes();
- Type[] parameterTypes =
- new Type[extractedMethodParameterTypes.length
- + adviceParameterTypes.length
- + 1];
+ // then here the munger signature will have 'Foo' as an argument in it whilst the adviceMethod argument type will be
+ // 'Object' - since
+ // it represents the advice method in the superaspect which uses the erasure of the type variable p(Object t) - see
+ // pr174449.
+
+ Type[] adviceParameterTypes = BcelWorld.makeBcelTypes(munger.getSignature().getParameterTypes());
+ // adviceMethod.getArgumentTypes();
+ adviceMethod.getArgumentTypes(); // forces initialization ... dont like this but seems to be required for some tests to
+ // pass, I think that means
+ // there is a LazyMethodGen method that is not correctly setup to call initialize() when it is invoked - but I dont have
+ // time right now to discover which
+ Type[] extractedMethodParameterTypes = extractedMethod.getArgumentTypes();
+ Type[] parameterTypes = new Type[extractedMethodParameterTypes.length + adviceParameterTypes.length + 1];
int parameterIndex = 0;
- System.arraycopy(
- extractedMethodParameterTypes,
- 0,
- parameterTypes,
- parameterIndex,
- extractedMethodParameterTypes.length);
+ System.arraycopy(extractedMethodParameterTypes, 0, parameterTypes, parameterIndex, extractedMethodParameterTypes.length);
parameterIndex += extractedMethodParameterTypes.length;
- parameterTypes[parameterIndex++] =
- BcelWorld.makeBcelType(adviceMethod.getEnclosingClass().getType());
- System.arraycopy(
- adviceParameterTypes,
- 0,
- parameterTypes,
- parameterIndex,
- adviceParameterTypes.length);
-// parameterTypes is [Bug, C, org.aspectj.lang.JoinPoint, X, org.aspectj.lang.ProceedingJoinPoint, java.lang.Object, java.lang.Object]
- LazyMethodGen localAdviceMethod =
- new LazyMethodGen(
- Modifier.PRIVATE | Modifier.FINAL | Modifier.STATIC,
- BcelWorld.makeBcelType(mungerSig.getReturnType()),
- adviceMethodName,
- parameterTypes,
- new String[0],
- getEnclosingClass());
-
+ parameterTypes[parameterIndex++] = BcelWorld.makeBcelType(adviceMethod.getEnclosingClass().getType());
+ System.arraycopy(adviceParameterTypes, 0, parameterTypes, parameterIndex, adviceParameterTypes.length);
+ // parameterTypes is [Bug, C, org.aspectj.lang.JoinPoint, X, org.aspectj.lang.ProceedingJoinPoint, java.lang.Object,
+ // java.lang.Object]
+ LazyMethodGen localAdviceMethod = new LazyMethodGen(Modifier.PRIVATE | Modifier.FINAL | Modifier.STATIC, BcelWorld
+ .makeBcelType(mungerSig.getReturnType()), adviceMethodName, parameterTypes, new String[0], getEnclosingClass());
+
String donorFileName = adviceMethod.getEnclosingClass().getInternalFileName();
String recipientFileName = getEnclosingClass().getInternalFileName();
-// System.err.println("donor " + donorFileName);
-// System.err.println("recip " + recipientFileName);
- if (! donorFileName.equals(recipientFileName)) {
+ // System.err.println("donor " + donorFileName);
+ // System.err.println("recip " + recipientFileName);
+ if (!donorFileName.equals(recipientFileName)) {
localAdviceMethod.fromFilename = donorFileName;
- getEnclosingClass().addInlinedSourceFileInfo(
- donorFileName,
- adviceMethod.highestLineNumber);
+ getEnclosingClass().addInlinedSourceFileInfo(donorFileName, adviceMethod.highestLineNumber);
}
-
+
getEnclosingClass().addMethodGen(localAdviceMethod);
-
+
// create a map that will move all slots in advice method forward by extraParamOffset
// in order to make room for the new proceed-required arguments that are added at
// the beginning of the parameter list
int nVars = adviceMethod.getMaxLocals() + extraParamOffset;
IntMap varMap = IntMap.idMap(nVars);
- for (int i=extraParamOffset; i < nVars; i++) {
- varMap.put(i-extraParamOffset, i);
+ for (int i = extraParamOffset; i < nVars; i++) {
+ varMap.put(i - extraParamOffset, i);
}
localAdviceMethod.getBody().insert(
- BcelClassWeaver.genInlineInstructions(adviceMethod,
- localAdviceMethod, varMap, fact, true));
+ BcelClassWeaver.genInlineInstructions(adviceMethod, localAdviceMethod, varMap, fact, true));
-
-
localAdviceMethod.setMaxLocals(nVars);
-
- //System.err.println(localAdviceMethod);
-
-
- // the shadow is now empty. First, create a correct call
- // to the around advice. This includes both the call (which may involve
- // value conversion of the advice arguments) and the return
- // (which may involve value conversion of the return value). Right now
- // we push a null for the unused closure. It's sad, but there it is.
-
- InstructionList advice = new InstructionList();
- // InstructionHandle adviceMethodInvocation;
- {
- for (Iterator i = argVarList.iterator(); i.hasNext(); ) {
- BcelVar var = (BcelVar)i.next();
+
+ // System.err.println(localAdviceMethod);
+
+ // the shadow is now empty. First, create a correct call
+ // to the around advice. This includes both the call (which may involve
+ // value conversion of the advice arguments) and the return
+ // (which may involve value conversion of the return value). Right now
+ // we push a null for the unused closure. It's sad, but there it is.
+
+ InstructionList advice = new InstructionList();
+ // InstructionHandle adviceMethodInvocation;
+ {
+ for (Iterator i = argVarList.iterator(); i.hasNext();) {
+ BcelVar var = (BcelVar) i.next();
var.appendLoad(advice, fact);
- }
- // ??? we don't actually need to push NULL for the closure if we take care
- advice.append(
- munger.getAdviceArgSetup(
- this,
- null,
- (munger.getConcreteAspect().isAnnotationStyleAspect() && munger.getDeclaringAspect()!=null && munger.getDeclaringAspect().resolve(world).isAnnotationStyleAspect())?
- this.loadThisJoinPoint():
- new InstructionList(InstructionConstants.ACONST_NULL)));
- // adviceMethodInvocation =
- advice.append(
- Utility.createInvoke(fact, localAdviceMethod)); //(fact, getWorld(), munger.getSignature()));
- advice.append(
- Utility.createConversion(
- getFactory(),
- BcelWorld.makeBcelType(mungerSig.getReturnType()),
- extractedMethod.getReturnType(),world.isInJava5Mode()));
- if (! isFallsThrough()) {
- advice.append(InstructionFactory.createReturn(extractedMethod.getReturnType()));
- }
- }
-
+ }
+ // ??? we don't actually need to push NULL for the closure if we take care
+ advice.append(munger.getAdviceArgSetup(this, null,
+ (munger.getConcreteAspect().isAnnotationStyleAspect() && munger.getDeclaringAspect() != null && munger
+ .getDeclaringAspect().resolve(world).isAnnotationStyleAspect()) ? this.loadThisJoinPoint()
+ : new InstructionList(InstructionConstants.ACONST_NULL)));
+ // adviceMethodInvocation =
+ advice.append(Utility.createInvoke(fact, localAdviceMethod)); // (fact, getWorld(), munger.getSignature()));
+ advice.append(Utility.createConversion(getFactory(), BcelWorld.makeBcelType(mungerSig.getReturnType()), extractedMethod
+ .getReturnType(), world.isInJava5Mode()));
+ if (!isFallsThrough()) {
+ advice.append(InstructionFactory.createReturn(extractedMethod.getReturnType()));
+ }
+ }
+
// now, situate the call inside the possible dynamic tests,
// and actually add the whole mess to the shadow
- if (! hasDynamicTest) {
- range.append(advice);
- } else {
- InstructionList afterThingie = new InstructionList(InstructionConstants.NOP);
- InstructionList callback = makeCallToCallback(extractedMethod);
+ if (!hasDynamicTest) {
+ range.append(advice);
+ } else {
+ InstructionList afterThingie = new InstructionList(InstructionConstants.NOP);
+ InstructionList callback = makeCallToCallback(extractedMethod);
if (terminatesWithReturn()) {
- callback.append(
- InstructionFactory.createReturn(extractedMethod.getReturnType()));
+ callback.append(InstructionFactory.createReturn(extractedMethod.getReturnType()));
} else {
- //InstructionHandle endNop = range.insert(fact.NOP, Range.InsideAfter);
- advice.append(
- InstructionFactory.createBranchInstruction(
- Constants.GOTO,
- afterThingie.getStart()));
+ // InstructionHandle endNop = range.insert(fact.NOP, Range.InsideAfter);
+ advice.append(InstructionFactory.createBranchInstruction(Constants.GOTO, afterThingie.getStart()));
+ }
+ range.append(munger.getTestInstructions(this, advice.getStart(), callback.getStart(), advice.getStart()));
+ range.append(advice);
+ range.append(callback);
+ range.append(afterThingie);
+ }
+
+ // now search through the advice, looking for a call to PROCEED.
+ // Then we replace the call to proceed with some argument setup, and a
+ // call to the extracted method.
+
+ // inlining support for code style aspects
+ if (!munger.getDeclaringType().isAnnotationStyleAspect()) {
+ String proceedName = NameMangler.proceedMethodName(munger.getSignature().getName());
+
+ InstructionHandle curr = localAdviceMethod.getBody().getStart();
+ InstructionHandle end = localAdviceMethod.getBody().getEnd();
+ ConstantPool cpg = localAdviceMethod.getEnclosingClass().getConstantPool();
+ while (curr != end) {
+ InstructionHandle next = curr.getNext();
+ Instruction inst = curr.getInstruction();
+ if ((inst.opcode == Constants.INVOKESTATIC) && proceedName.equals(((InvokeInstruction) inst).getMethodName(cpg))) {
+
+ localAdviceMethod.getBody().append(curr,
+ getRedoneProceedCall(fact, extractedMethod, munger, localAdviceMethod, proceedVarList));
+ Utility.deleteInstruction(curr, localAdviceMethod);
+ }
+ curr = next;
}
- range.append(
- munger.getTestInstructions(
- this,
- advice.getStart(),
- callback.getStart(),
- advice.getStart()));
- range.append(advice);
- range.append(callback);
- range.append(afterThingie);
- }
-
-
- // now search through the advice, looking for a call to PROCEED.
- // Then we replace the call to proceed with some argument setup, and a
- // call to the extracted method.
-
- // inlining support for code style aspects
- if (!munger.getDeclaringType().isAnnotationStyleAspect()) {
- String proceedName =
- NameMangler.proceedMethodName(munger.getSignature().getName());
-
- InstructionHandle curr = localAdviceMethod.getBody().getStart();
- InstructionHandle end = localAdviceMethod.getBody().getEnd();
- ConstantPool cpg = localAdviceMethod.getEnclosingClass().getConstantPool();
- while (curr != end) {
- InstructionHandle next = curr.getNext();
- Instruction inst = curr.getInstruction();
- if ((inst.opcode==Constants.INVOKESTATIC)
- && proceedName.equals(((InvokeInstruction) inst).getMethodName(cpg))) {
-
- localAdviceMethod.getBody().append(
- curr,
- getRedoneProceedCall(
- fact,
- extractedMethod,
- munger,
- localAdviceMethod,
- proceedVarList));
- Utility.deleteInstruction(curr, localAdviceMethod);
- }
- curr = next;
- }
- // and that's it.
- } else {
- //ATAJ inlining support for @AJ aspects
- // [TODO document @AJ code rule: don't manipulate 2 jps proceed at the same time.. in an advice body]
- InstructionHandle curr = localAdviceMethod.getBody().getStart();
- InstructionHandle end = localAdviceMethod.getBody().getEnd();
- ConstantPool cpg = localAdviceMethod.getEnclosingClass().getConstantPool();
- while (curr != end) {
- InstructionHandle next = curr.getNext();
- Instruction inst = curr.getInstruction();
- if ((inst instanceof INVOKEINTERFACE)
- && "proceed".equals(((INVOKEINTERFACE) inst).getMethodName(cpg))) {
- final boolean isProceedWithArgs;
- if (((INVOKEINTERFACE) inst).getArgumentTypes(cpg).length == 1) {
- // proceed with args as a boxed Object[]
- isProceedWithArgs = true;
- } else {
- isProceedWithArgs = false;
- }
- InstructionList insteadProceedIl = getRedoneProceedCallForAnnotationStyle(
- fact,
- extractedMethod,
- munger,
- localAdviceMethod,
- proceedVarList,
- isProceedWithArgs
- );
- localAdviceMethod.getBody().append(curr, insteadProceedIl);
- Utility.deleteInstruction(curr, localAdviceMethod);
- }
- curr = next;
- }
- }
- }
-
- private InstructionList getRedoneProceedCall(
- InstructionFactory fact,
- LazyMethodGen callbackMethod,
- BcelAdvice munger,
- LazyMethodGen localAdviceMethod,
- List argVarList)
- {
+ // and that's it.
+ } else {
+ // ATAJ inlining support for @AJ aspects
+ // [TODO document @AJ code rule: don't manipulate 2 jps proceed at the same time.. in an advice body]
+ InstructionHandle curr = localAdviceMethod.getBody().getStart();
+ InstructionHandle end = localAdviceMethod.getBody().getEnd();
+ ConstantPool cpg = localAdviceMethod.getEnclosingClass().getConstantPool();
+ while (curr != end) {
+ InstructionHandle next = curr.getNext();
+ Instruction inst = curr.getInstruction();
+ if ((inst instanceof INVOKEINTERFACE) && "proceed".equals(((INVOKEINTERFACE) inst).getMethodName(cpg))) {
+ final boolean isProceedWithArgs;
+ if (((INVOKEINTERFACE) inst).getArgumentTypes(cpg).length == 1) {
+ // proceed with args as a boxed Object[]
+ isProceedWithArgs = true;
+ } else {
+ isProceedWithArgs = false;
+ }
+ InstructionList insteadProceedIl = getRedoneProceedCallForAnnotationStyle(fact, extractedMethod, munger,
+ localAdviceMethod, proceedVarList, isProceedWithArgs);
+ localAdviceMethod.getBody().append(curr, insteadProceedIl);
+ Utility.deleteInstruction(curr, localAdviceMethod);
+ }
+ curr = next;
+ }
+ }
+ }
+
+ private InstructionList getRedoneProceedCall(InstructionFactory fact, LazyMethodGen callbackMethod, BcelAdvice munger,
+ LazyMethodGen localAdviceMethod, List argVarList) {
InstructionList ret = new InstructionList();
// we have on stack all the arguments for the ADVICE call.
// we have in frame somewhere all the arguments for the non-advice call.
-
+
BcelVar[] adviceVars = munger.getExposedStateAsBcelVars(true);
- IntMap proceedMap = makeProceedArgumentMap(adviceVars);
+ IntMap proceedMap = makeProceedArgumentMap(adviceVars);
+
+ // System.out.println(proceedMap + " for " + this);
+ // System.out.println(argVarList);
-// System.out.println(proceedMap + " for " + this);
-// System.out.println(argVarList);
-
- ResolvedType[] proceedParamTypes =
- world.resolve(munger.getSignature().getParameterTypes());
+ ResolvedType[] proceedParamTypes = world.resolve(munger.getSignature().getParameterTypes());
// remove this*JoinPoint* as arguments to proceed
- if (munger.getBaseParameterCount()+1 < proceedParamTypes.length) {
- int len = munger.getBaseParameterCount()+1;
+ if (munger.getBaseParameterCount() + 1 < proceedParamTypes.length) {
+ int len = munger.getBaseParameterCount() + 1;
ResolvedType[] newTypes = new ResolvedType[len];
System.arraycopy(proceedParamTypes, 0, newTypes, 0, len);
proceedParamTypes = newTypes;
}
- //System.out.println("stateTypes: " + Arrays.asList(stateTypes));
- BcelVar[] proceedVars =
- Utility.pushAndReturnArrayOfVars(proceedParamTypes, ret, fact, localAdviceMethod);
+ // System.out.println("stateTypes: " + Arrays.asList(stateTypes));
+ BcelVar[] proceedVars = Utility.pushAndReturnArrayOfVars(proceedParamTypes, ret, fact, localAdviceMethod);
Type[] stateTypes = callbackMethod.getArgumentTypes();
-// System.out.println("stateTypes: " + Arrays.asList(stateTypes));
-
- for (int i=0, len=stateTypes.length; i < len; i++) {
- Type stateType = stateTypes[i];
- ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
- if (proceedMap.hasKey(i)) {
- //throw new RuntimeException("unimplemented");
+ // System.out.println("stateTypes: " + Arrays.asList(stateTypes));
+
+ for (int i = 0, len = stateTypes.length; i < len; i++) {
+ Type stateType = stateTypes[i];
+ ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
+ if (proceedMap.hasKey(i)) {
+ // throw new RuntimeException("unimplemented");
proceedVars[proceedMap.get(i)].appendLoadAndConvert(ret, fact, stateTypeX);
- } else {
+ } else {
((BcelVar) argVarList.get(i)).appendLoad(ret, fact);
- }
+ }
+ }
+
+ ret.append(Utility.createInvoke(fact, callbackMethod));
+ ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(), BcelWorld.makeBcelType(munger.getSignature()
+ .getReturnType())));
+ return ret;
+ }
+
+ // private static boolean bindsThisOrTarget(Pointcut pointcut) {
+ // ThisTargetFinder visitor = new ThisTargetFinder();
+ // pointcut.accept(visitor, null);
+ // return visitor.bindsThisOrTarget;
+ // }
+
+ // private static class ThisTargetFinder extends IdentityPointcutVisitor {
+ // boolean bindsThisOrTarget = false;
+ //
+ // public Object visit(ThisOrTargetPointcut node, Object data) {
+ // if (node.isBinding()) {
+ // bindsThisOrTarget = true;
+ // }
+ // return node;
+ // }
+ //
+ // public Object visit(AndPointcut node, Object data) {
+ // if (!bindsThisOrTarget) node.getLeft().accept(this, data);
+ // if (!bindsThisOrTarget) node.getRight().accept(this, data);
+ // return node;
+ // }
+ //
+ // public Object visit(NotPointcut node, Object data) {
+ // if (!bindsThisOrTarget) node.getNegatedPointcut().accept(this, data);
+ // return node;
+ // }
+ //
+ // public Object visit(OrPointcut node, Object data) {
+ // if (!bindsThisOrTarget) node.getLeft().accept(this, data);
+ // if (!bindsThisOrTarget) node.getRight().accept(this, data);
+ // return node;
+ // }
+ // }
+
+ /**
+ * Annotation style handling for inlining.
+ *
+ * Note: The proceedingjoinpoint is already on the stack (since the user was calling pjp.proceed(...)
+ *
+ * The proceed map is ignored (in terms of argument repositioning) since we have a fixed expected format for annotation style.
+ * The aim here is to change the proceed() call into a call to the xxx_aroundBody0 method.
+ *
+ *
+ */
+ private InstructionList getRedoneProceedCallForAnnotationStyle(InstructionFactory fact, LazyMethodGen callbackMethod,
+ BcelAdvice munger, LazyMethodGen localAdviceMethod, List argVarList, boolean isProceedWithArgs) {
+ InstructionList ret = new InstructionList();
+
+ // store the Object[] array on stack if proceed with args
+ if (isProceedWithArgs) {
+
+ // STORE the Object[] into a local variable
+ Type objectArrayType = Type.OBJECT_ARRAY;
+ int theObjectArrayLocalNumber = localAdviceMethod.allocateLocal(objectArrayType);
+ ret.append(InstructionFactory.createStore(objectArrayType, theObjectArrayLocalNumber));
+
+ // STORE the ProceedingJoinPoint instance into a local variable
+ Type proceedingJpType = Type.getType("Lorg/aspectj/lang/ProceedingJoinPoint;");
+ int pjpLocalNumber = localAdviceMethod.allocateLocal(proceedingJpType);
+ ret.append(InstructionFactory.createStore(proceedingJpType, pjpLocalNumber));
+
+ // Aim here initially is to determine whether the user will have provided a new
+ // this/target in the object array and consume them if they have, leaving us the rest of
+ // the arguments to process as regular arguments to the invocation at the original join point
+
+ boolean pointcutBindsThis = bindsThis(munger);
+ boolean pointcutBindsTarget = bindsTarget(munger);
+ boolean targetIsSameAsThis = getKind().isTargetSameAsThis();
+
+ int nextArgumentToProvideForCallback = 0;
+
+ if (hasThis()) {
+ if (!(pointcutBindsTarget && targetIsSameAsThis)) {
+ if (pointcutBindsThis) {
+ // they have supplied new this as first entry in object array, consume it
+ ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
+ ret.append(Utility.createConstant(fact, 0));
+ ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
+ ret.append(Utility.createConversion(fact, Type.OBJECT, callbackMethod.getArgumentTypes()[0]));
+ } else {
+ // use local variable 0
+ ret.append(InstructionFactory.createALOAD(0));
+ }
+ nextArgumentToProvideForCallback++;
+ }
+ }
+
+ if (hasTarget()) {
+ if (pointcutBindsTarget) {
+ if (getKind().isTargetSameAsThis()) {
+ ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
+ ret.append(Utility.createConstant(fact, pointcutBindsThis ? 1 : 0));
+ ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
+ ret.append(Utility.createConversion(fact, Type.OBJECT, callbackMethod.getArgumentTypes()[0]));
+ } else {
+ int position = (hasThis() && pointcutBindsThis ? 1 : 0);
+ ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
+ ret.append(Utility.createConstant(fact, position));
+ ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
+ ret.append(Utility.createConversion(fact, Type.OBJECT, callbackMethod.getArgumentTypes()[position]));
+ }
+ nextArgumentToProvideForCallback++;
+ } else {
+ if (getKind().isTargetSameAsThis()) {
+ // ret.append(new ALOAD(0));
+ } else {
+ ret.append(InstructionFactory.createLoad(localAdviceMethod.getArgumentTypes()[0], hasThis() ? 1 : 0));
+ nextArgumentToProvideForCallback++;
+ }
+ }
+ }
+
+ // Where to start in the object array in order to pick up arguments
+ int indexIntoObjectArrayForArguments = (pointcutBindsThis ? 1 : 0) + (pointcutBindsTarget ? 1 : 0);
+
+ int len = callbackMethod.getArgumentTypes().length;
+ for (int i = nextArgumentToProvideForCallback; i < len; i++) {
+ Type stateType = callbackMethod.getArgumentTypes()[i];
+ BcelWorld.fromBcel(stateType).resolve(world);
+ if ("Lorg/aspectj/lang/JoinPoint;".equals(stateType.getSignature())) {
+ ret.append(new InstructionLV(Constants.ALOAD, pjpLocalNumber));
+ } else {
+ ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
+ ret.append(Utility
+ .createConstant(fact, i - nextArgumentToProvideForCallback + indexIntoObjectArrayForArguments));
+ ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
+ ret.append(Utility.createConversion(fact, Type.OBJECT, stateType));
+ }
+ }
+
+ } else {
+ Type proceedingJpType = Type.getType("Lorg/aspectj/lang/ProceedingJoinPoint;");
+ int localJp = localAdviceMethod.allocateLocal(proceedingJpType);
+ ret.append(InstructionFactory.createStore(proceedingJpType, localJp));
+
+ for (int i = 0, len = callbackMethod.getArgumentTypes().length; i < len; i++) {
+ Type stateType = callbackMethod.getArgumentTypes()[i];
+ /* ResolvedType stateTypeX = */
+ BcelWorld.fromBcel(stateType).resolve(world);
+ if ("Lorg/aspectj/lang/JoinPoint;".equals(stateType.getSignature())) {
+ ret.append(InstructionFactory.createALOAD(localJp));// from localAdvice signature
+ // } else if ("Lorg/aspectj/lang/ProceedingJoinPoint;".equals(stateType.getSignature())) {
+ // //FIXME ALEX?
+ // ret.append(new ALOAD(localJp));// from localAdvice signature
+ // // ret.append(fact.createCheckCast(
+ // // (ReferenceType) BcelWorld.makeBcelType(stateTypeX)
+ // // ));
+ // // cast ?
+ //
+ } else {
+ ret.append(InstructionFactory.createLoad(stateType, i));
+ }
+ }
}
-
+
+ // do the callback invoke
ret.append(Utility.createInvoke(fact, callbackMethod));
- ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(),
- BcelWorld.makeBcelType(munger.getSignature().getReturnType())));
+
+ // box it again. Handles cases where around advice does return something else than Object
+ if (!UnresolvedType.OBJECT.equals(munger.getSignature().getReturnType())) {
+ ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(), Type.OBJECT));
+ }
+ ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(), BcelWorld.makeBcelType(munger.getSignature()
+ .getReturnType())));
+
return ret;
+
+ //
+ //
+ //
+ // if (proceedMap.hasKey(i)) {
+ // ret.append(new ALOAD(i));
+ // //throw new RuntimeException("unimplemented");
+ // //proceedVars[proceedMap.get(i)].appendLoadAndConvert(ret, fact, stateTypeX);
+ // } else {
+ // //((BcelVar) argVarList.get(i)).appendLoad(ret, fact);
+ // //ret.append(new ALOAD(i));
+ // if ("Lorg/aspectj/lang/JoinPoint;".equals(stateType.getSignature())) {
+ // ret.append(new ALOAD(i));
+ // } else {
+ // ret.append(new ALOAD(i));
+ // }
+ // }
+ // }
+ //
+ // ret.append(Utility.createInvoke(fact, callbackMethod));
+ // ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(),
+ // BcelWorld.makeBcelType(munger.getSignature().getReturnType())));
+ //
+ // //ret.append(new ACONST_NULL());//will be POPed
+ // if (true) return ret;
+ //
+ //
+ //
+ // // we have on stack all the arguments for the ADVICE call.
+ // // we have in frame somewhere all the arguments for the non-advice call.
+ //
+ // BcelVar[] adviceVars = munger.getExposedStateAsBcelVars();
+ // IntMap proceedMap = makeProceedArgumentMap(adviceVars);
+ //
+ // System.out.println(proceedMap + " for " + this);
+ // System.out.println(argVarList);
+ //
+ // ResolvedType[] proceedParamTypes =
+ // world.resolve(munger.getSignature().getParameterTypes());
+ // // remove this*JoinPoint* as arguments to proceed
+ // if (munger.getBaseParameterCount()+1 < proceedParamTypes.length) {
+ // int len = munger.getBaseParameterCount()+1;
+ // ResolvedType[] newTypes = new ResolvedType[len];
+ // System.arraycopy(proceedParamTypes, 0, newTypes, 0, len);
+ // proceedParamTypes = newTypes;
+ // }
+ //
+ // //System.out.println("stateTypes: " + Arrays.asList(stateTypes));
+ // BcelVar[] proceedVars =
+ // Utility.pushAndReturnArrayOfVars(proceedParamTypes, ret, fact, localAdviceMethod);
+ //
+ // Type[] stateTypes = callbackMethod.getArgumentTypes();
+ // // System.out.println("stateTypes: " + Arrays.asList(stateTypes));
+ //
+ // for (int i=0, len=stateTypes.length; i < len; i++) {
+ // Type stateType = stateTypes[i];
+ // ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
+ // if (proceedMap.hasKey(i)) {
+ // //throw new RuntimeException("unimplemented");
+ // proceedVars[proceedMap.get(i)].appendLoadAndConvert(ret, fact, stateTypeX);
+ // } else {
+ // ((BcelVar) argVarList.get(i)).appendLoad(ret, fact);
+ // }
+ // }
+ //
+ // ret.append(Utility.createInvoke(fact, callbackMethod));
+ // ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(),
+ // BcelWorld.makeBcelType(munger.getSignature().getReturnType())));
+ // return ret;
}
-
-// private static boolean bindsThisOrTarget(Pointcut pointcut) {
-// ThisTargetFinder visitor = new ThisTargetFinder();
-// pointcut.accept(visitor, null);
-// return visitor.bindsThisOrTarget;
-// }
-
-// private static class ThisTargetFinder extends IdentityPointcutVisitor {
-// boolean bindsThisOrTarget = false;
-//
-// public Object visit(ThisOrTargetPointcut node, Object data) {
-// if (node.isBinding()) {
-// bindsThisOrTarget = true;
-// }
-// return node;
-// }
-//
-// public Object visit(AndPointcut node, Object data) {
-// if (!bindsThisOrTarget) node.getLeft().accept(this, data);
-// if (!bindsThisOrTarget) node.getRight().accept(this, data);
-// return node;
-// }
-//
-// public Object visit(NotPointcut node, Object data) {
-// if (!bindsThisOrTarget) node.getNegatedPointcut().accept(this, data);
-// return node;
-// }
-//
-// public Object visit(OrPointcut node, Object data) {
-// if (!bindsThisOrTarget) node.getLeft().accept(this, data);
-// if (!bindsThisOrTarget) node.getRight().accept(this, data);
-// return node;
-// }
-// }
-
-
- /**
- * Annotation style handling for inlining.
- *
- * Note:
- * The proceedingjoinpoint is already on the stack (since the user was calling pjp.proceed(...)
- *
- * The proceed map is ignored (in terms of argument repositioning) since we have a fixed expected
- * format for annotation style. The aim here is to change the proceed() call into a call to
- * the xxx_aroundBody0 method.
- *
- *
- */
- private InstructionList getRedoneProceedCallForAnnotationStyle(
- InstructionFactory fact,
- LazyMethodGen callbackMethod,
- BcelAdvice munger,
- LazyMethodGen localAdviceMethod,
- List argVarList,
- boolean isProceedWithArgs)
- {
- InstructionList ret = new InstructionList();
-
- // store the Object[] array on stack if proceed with args
- if (isProceedWithArgs) {
-
- // STORE the Object[] into a local variable
- Type objectArrayType = Type.OBJECT_ARRAY;
- int theObjectArrayLocalNumber = localAdviceMethod.allocateLocal(objectArrayType);
- ret.append(InstructionFactory.createStore(objectArrayType, theObjectArrayLocalNumber));
-
- // STORE the ProceedingJoinPoint instance into a local variable
- Type proceedingJpType = Type.getType("Lorg/aspectj/lang/ProceedingJoinPoint;");
- int pjpLocalNumber = localAdviceMethod.allocateLocal(proceedingJpType);
- ret.append(InstructionFactory.createStore(proceedingJpType, pjpLocalNumber));
-
- // Aim here initially is to determine whether the user will have provided a new
- // this/target in the object array and consume them if they have, leaving us the rest of
- // the arguments to process as regular arguments to the invocation at the original join point
-
- boolean pointcutBindsThis = bindsThis(munger);
- boolean pointcutBindsTarget = bindsTarget(munger);
- boolean targetIsSameAsThis = getKind().isTargetSameAsThis();
-
- int nextArgumentToProvideForCallback = 0;
-
- if (hasThis() ) {
- if (!(pointcutBindsTarget && targetIsSameAsThis)) {
- if (pointcutBindsThis) {
- // they have supplied new this as first entry in object array, consume it
- ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
- ret.append(Utility.createConstant(fact, 0));
- ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
- ret.append(Utility.createConversion(fact,Type.OBJECT,callbackMethod.getArgumentTypes()[0]));
- } else {
- // use local variable 0
- ret.append(InstructionFactory.createALOAD(0));
- }
- nextArgumentToProvideForCallback++;
- }
- }
-
-
-
- if (hasTarget()) {
- if (pointcutBindsTarget) {
- if (getKind().isTargetSameAsThis()) {
- ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
- ret.append(Utility.createConstant(fact, pointcutBindsThis?1:0));
- ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
- ret.append(Utility.createConversion(fact,Type.OBJECT,callbackMethod.getArgumentTypes()[0]));
- } else {
- int position =(hasThis()&& pointcutBindsThis?1:0);
- ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
- ret.append(Utility.createConstant(fact, position));
- ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
- ret.append(Utility.createConversion(fact,Type.OBJECT,callbackMethod.getArgumentTypes()[position]));
- }
- nextArgumentToProvideForCallback++;
- } else {
- if (getKind().isTargetSameAsThis()) {
- //ret.append(new ALOAD(0));
- } else {
- ret.append(InstructionFactory.createLoad(localAdviceMethod.getArgumentTypes()[0],hasThis()?1:0));
- nextArgumentToProvideForCallback++;
- }
- }
- }
-
- // Where to start in the object array in order to pick up arguments
- int indexIntoObjectArrayForArguments = (pointcutBindsThis?1:0)+(pointcutBindsTarget?1:0);
-
- int len = callbackMethod.getArgumentTypes().length;
- for (int i = nextArgumentToProvideForCallback; i < len; i++) {
- Type stateType = callbackMethod.getArgumentTypes()[i];
- BcelWorld.fromBcel(stateType).resolve(world);
- if ("Lorg/aspectj/lang/JoinPoint;".equals(stateType.getSignature())) {
- ret.append(new InstructionLV(Constants.ALOAD, pjpLocalNumber));
- } else {
- ret.append(InstructionFactory.createLoad(objectArrayType, theObjectArrayLocalNumber));
- ret.append(Utility.createConstant(fact, i-nextArgumentToProvideForCallback+indexIntoObjectArrayForArguments));
- ret.append(InstructionFactory.createArrayLoad(Type.OBJECT));
- ret.append(Utility.createConversion(fact, Type.OBJECT, stateType));
- }
- }
-
- } else {
- Type proceedingJpType = Type.getType("Lorg/aspectj/lang/ProceedingJoinPoint;");
- int localJp = localAdviceMethod.allocateLocal(proceedingJpType);
- ret.append(InstructionFactory.createStore(proceedingJpType, localJp));
-
- for (int i = 0, len=callbackMethod.getArgumentTypes().length; i < len; i++) {
- Type stateType = callbackMethod.getArgumentTypes()[i];
- /*ResolvedType stateTypeX =*/
- BcelWorld.fromBcel(stateType).resolve(world);
- if ("Lorg/aspectj/lang/JoinPoint;".equals(stateType.getSignature())) {
- ret.append(InstructionFactory.createALOAD(localJp));// from localAdvice signature
-// } else if ("Lorg/aspectj/lang/ProceedingJoinPoint;".equals(stateType.getSignature())) {
-// //FIXME ALEX?
-// ret.append(new ALOAD(localJp));// from localAdvice signature
-//// ret.append(fact.createCheckCast(
-//// (ReferenceType) BcelWorld.makeBcelType(stateTypeX)
-//// ));
-// // cast ?
-//
- } else {
- ret.append(InstructionFactory.createLoad(stateType, i));
- }
- }
- }
-
- // do the callback invoke
- ret.append(Utility.createInvoke(fact, callbackMethod));
-
- // box it again. Handles cases where around advice does return something else than Object
- if (!UnresolvedType.OBJECT.equals(munger.getSignature().getReturnType())) {
- ret.append(Utility.createConversion(
- fact,
- callbackMethod.getReturnType(),
- Type.OBJECT
- ));
- }
- ret.append(Utility.createConversion(
- fact,
- callbackMethod.getReturnType(),
- BcelWorld.makeBcelType(munger.getSignature().getReturnType())
- ));
-
- return ret;
-
-//
-//
-//
-// if (proceedMap.hasKey(i)) {
-// ret.append(new ALOAD(i));
-// //throw new RuntimeException("unimplemented");
-// //proceedVars[proceedMap.get(i)].appendLoadAndConvert(ret, fact, stateTypeX);
-// } else {
-// //((BcelVar) argVarList.get(i)).appendLoad(ret, fact);
-// //ret.append(new ALOAD(i));
-// if ("Lorg/aspectj/lang/JoinPoint;".equals(stateType.getSignature())) {
-// ret.append(new ALOAD(i));
-// } else {
-// ret.append(new ALOAD(i));
-// }
-// }
-// }
-//
-// ret.append(Utility.createInvoke(fact, callbackMethod));
-// ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(),
-// BcelWorld.makeBcelType(munger.getSignature().getReturnType())));
-//
-// //ret.append(new ACONST_NULL());//will be POPed
-// if (true) return ret;
-//
-//
-//
-// // we have on stack all the arguments for the ADVICE call.
-// // we have in frame somewhere all the arguments for the non-advice call.
-//
-// BcelVar[] adviceVars = munger.getExposedStateAsBcelVars();
-// IntMap proceedMap = makeProceedArgumentMap(adviceVars);
-//
-// System.out.println(proceedMap + " for " + this);
-// System.out.println(argVarList);
-//
-// ResolvedType[] proceedParamTypes =
-// world.resolve(munger.getSignature().getParameterTypes());
-// // remove this*JoinPoint* as arguments to proceed
-// if (munger.getBaseParameterCount()+1 < proceedParamTypes.length) {
-// int len = munger.getBaseParameterCount()+1;
-// ResolvedType[] newTypes = new ResolvedType[len];
-// System.arraycopy(proceedParamTypes, 0, newTypes, 0, len);
-// proceedParamTypes = newTypes;
-// }
-//
-// //System.out.println("stateTypes: " + Arrays.asList(stateTypes));
-// BcelVar[] proceedVars =
-// Utility.pushAndReturnArrayOfVars(proceedParamTypes, ret, fact, localAdviceMethod);
-//
-// Type[] stateTypes = callbackMethod.getArgumentTypes();
-//// System.out.println("stateTypes: " + Arrays.asList(stateTypes));
-//
-// for (int i=0, len=stateTypes.length; i < len; i++) {
-// Type stateType = stateTypes[i];
-// ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
-// if (proceedMap.hasKey(i)) {
-// //throw new RuntimeException("unimplemented");
-// proceedVars[proceedMap.get(i)].appendLoadAndConvert(ret, fact, stateTypeX);
-// } else {
-// ((BcelVar) argVarList.get(i)).appendLoad(ret, fact);
-// }
-// }
-//
-// ret.append(Utility.createInvoke(fact, callbackMethod));
-// ret.append(Utility.createConversion(fact, callbackMethod.getReturnType(),
-// BcelWorld.makeBcelType(munger.getSignature().getReturnType())));
-// return ret;
- }
-
- private boolean bindsThis(BcelAdvice munger) {
- UsesThisVisitor utv = new UsesThisVisitor();
- munger.getPointcut().accept(utv, null);
+
+ private boolean bindsThis(BcelAdvice munger) {
+ UsesThisVisitor utv = new UsesThisVisitor();
+ munger.getPointcut().accept(utv, null);
return utv.usesThis;
}
- private boolean bindsTarget(BcelAdvice munger) {
- UsesTargetVisitor utv = new UsesTargetVisitor();
- munger.getPointcut().accept(utv, null);
+ private boolean bindsTarget(BcelAdvice munger) {
+ UsesTargetVisitor utv = new UsesTargetVisitor();
+ munger.getPointcut().accept(utv, null);
return utv.usesTarget;
}
-
- private static class UsesThisVisitor extends IdentityPointcutVisitor {
- boolean usesThis = false;
-
- public Object visit(ThisOrTargetPointcut node, Object data) {
- if (node.isThis() && node.isBinding()) usesThis=true;
- return node;
- }
-
- public Object visit(AndPointcut node, Object data) {
- if (!usesThis) node.getLeft().accept(this, data);
- if (!usesThis) node.getRight().accept(this, data);
- return node;
- }
-
- public Object visit(NotPointcut node, Object data) {
- if (!usesThis) node.getNegatedPointcut().accept(this, data);
- return node;
- }
-
- public Object visit(OrPointcut node, Object data) {
- if (!usesThis) node.getLeft().accept(this, data);
- if (!usesThis) node.getRight().accept(this, data);
- return node;
- }
- }
-
-
- private static class UsesTargetVisitor extends IdentityPointcutVisitor {
- boolean usesTarget = false;
-
- public Object visit(ThisOrTargetPointcut node, Object data) {
- if (!node.isThis() && node.isBinding()) usesTarget=true;
- return node;
- }
-
- public Object visit(AndPointcut node, Object data) {
- if (!usesTarget) node.getLeft().accept(this, data);
- if (!usesTarget) node.getRight().accept(this, data);
- return node;
- }
-
- public Object visit(NotPointcut node, Object data) {
- if (!usesTarget) node.getNegatedPointcut().accept(this, data);
- return node;
- }
-
- public Object visit(OrPointcut node, Object data) {
- if (!usesTarget) node.getLeft().accept(this, data);
- if (!usesTarget) node.getRight().accept(this, data);
- return node;
- }
- }
+
+ private static class UsesThisVisitor extends AbstractPatternNodeVisitor {
+ boolean usesThis = false;
+
+ public Object visit(ThisOrTargetPointcut node, Object data) {
+ if (node.isThis() && node.isBinding())
+ usesThis = true;
+ return node;
+ }
+
+ public Object visit(AndPointcut node, Object data) {
+ if (!usesThis)
+ node.getLeft().accept(this, data);
+ if (!usesThis)
+ node.getRight().accept(this, data);
+ return node;
+ }
+
+ public Object visit(NotPointcut node, Object data) {
+ if (!usesThis)
+ node.getNegatedPointcut().accept(this, data);
+ return node;
+ }
+
+ public Object visit(OrPointcut node, Object data) {
+ if (!usesThis)
+ node.getLeft().accept(this, data);
+ if (!usesThis)
+ node.getRight().accept(this, data);
+ return node;
+ }
+ }
+
+ private static class UsesTargetVisitor extends AbstractPatternNodeVisitor {
+ boolean usesTarget = false;
+
+ public Object visit(ThisOrTargetPointcut node, Object data) {
+ if (!node.isThis() && node.isBinding())
+ usesTarget = true;
+ return node;
+ }
+
+ public Object visit(AndPointcut node, Object data) {
+ if (!usesTarget)
+ node.getLeft().accept(this, data);
+ if (!usesTarget)
+ node.getRight().accept(this, data);
+ return node;
+ }
+
+ public Object visit(NotPointcut node, Object data) {
+ if (!usesTarget)
+ node.getNegatedPointcut().accept(this, data);
+ return node;
+ }
+
+ public Object visit(OrPointcut node, Object data) {
+ if (!usesTarget)
+ node.getLeft().accept(this, data);
+ if (!usesTarget)
+ node.getRight().accept(this, data);
+ return node;
+ }
+ }
public void weaveAroundClosure(BcelAdvice munger, boolean hasDynamicTest) {
- InstructionFactory fact = getFactory();
+ InstructionFactory fact = getFactory();
enclosingMethod.setCanInline(false);
int linenumber = getSourceLine();
- // MOVE OUT ALL THE INSTRUCTIONS IN MY SHADOW INTO ANOTHER METHOD!
- LazyMethodGen callbackMethod =
- extractMethod(
- NameMangler.aroundCallbackMethodName(
- getSignature(),
- getEnclosingClass()),
- 0,
- munger);
-
- BcelVar[] adviceVars = munger.getExposedStateAsBcelVars(true);
-
- String closureClassName =
- NameMangler.makeClosureClassName(
- getEnclosingClass().getType(),
- getEnclosingClass().getNewGeneratedNameTag());
-
- Member constructorSig = new MemberImpl(Member.CONSTRUCTOR,
- UnresolvedType.forName(closureClassName), 0, "<init>",
- "([Ljava/lang/Object;)V");
-
- BcelVar closureHolder = null;
-
- // This is not being used currently since getKind() == preinitializaiton
- // cannot happen in around advice
- if (getKind() == PreInitialization) {
- closureHolder = genTempVar(AjcMemberMaker.AROUND_CLOSURE_TYPE);
- }
-
- InstructionList closureInstantiation =
- makeClosureInstantiation(constructorSig, closureHolder);
-
- /*LazyMethodGen constructor = */
- makeClosureClassAndReturnConstructor(
- closureClassName,
- callbackMethod,
- makeProceedArgumentMap(adviceVars)
- );
-
- InstructionList returnConversionCode;
+ // MOVE OUT ALL THE INSTRUCTIONS IN MY SHADOW INTO ANOTHER METHOD!
+ LazyMethodGen callbackMethod = extractMethod(NameMangler.aroundCallbackMethodName(getSignature(), getEnclosingClass()), 0,
+ munger);
+
+ BcelVar[] adviceVars = munger.getExposedStateAsBcelVars(true);
+
+ String closureClassName = NameMangler.makeClosureClassName(getEnclosingClass().getType(), getEnclosingClass()
+ .getNewGeneratedNameTag());
+
+ Member constructorSig = new MemberImpl(Member.CONSTRUCTOR, UnresolvedType.forName(closureClassName), 0, "<init>",
+ "([Ljava/lang/Object;)V");
+
+ BcelVar closureHolder = null;
+
+ // This is not being used currently since getKind() == preinitializaiton
+ // cannot happen in around advice
+ if (getKind() == PreInitialization) {
+ closureHolder = genTempVar(AjcMemberMaker.AROUND_CLOSURE_TYPE);
+ }
+
+ InstructionList closureInstantiation = makeClosureInstantiation(constructorSig, closureHolder);
+
+ /* LazyMethodGen constructor = */
+ makeClosureClassAndReturnConstructor(closureClassName, callbackMethod, makeProceedArgumentMap(adviceVars));
+
+ InstructionList returnConversionCode;
if (getKind() == PreInitialization) {
returnConversionCode = new InstructionList();
-
+
BcelVar stateTempVar = genTempVar(UnresolvedType.OBJECTARRAY);
closureHolder.appendLoad(returnConversionCode, fact);
-
- returnConversionCode.append(
- Utility.createInvoke(
- fact,
- world,
- AjcMemberMaker.aroundClosurePreInitializationGetter()));
+
+ returnConversionCode.append(Utility.createInvoke(fact, world, AjcMemberMaker.aroundClosurePreInitializationGetter()));
stateTempVar.appendStore(returnConversionCode, fact);
-
+
Type[] stateTypes = getSuperConstructorParameterTypes();
-
+
returnConversionCode.append(InstructionConstants.ALOAD_0); // put "this" back on the stack
for (int i = 0, len = stateTypes.length; i < len; i++) {
- UnresolvedType bcelTX = BcelWorld.fromBcel(stateTypes[i]);
- ResolvedType stateRTX = world.resolve(bcelTX,true);
- if (stateRTX.isMissing()) {
- world.getLint().cantFindType.signal(
- new String[] {WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE_PREINIT,bcelTX.getClassName())},
- getSourceLocation(),
- new ISourceLocation[]{ munger.getSourceLocation()}
- );
-// IMessage msg = new Message(
-// WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE_PREINIT,bcelTX.getClassName()),
-// "",IMessage.ERROR,getSourceLocation(),null,
-// new ISourceLocation[]{ munger.getSourceLocation()});
-// world.getMessageHandler().handleMessage(msg);
- }
- stateTempVar.appendConvertableArrayLoad(
- returnConversionCode,
- fact,
- i,
- stateRTX);
+ UnresolvedType bcelTX = BcelWorld.fromBcel(stateTypes[i]);
+ ResolvedType stateRTX = world.resolve(bcelTX, true);
+ if (stateRTX.isMissing()) {
+ world.getLint().cantFindType.signal(new String[] { WeaverMessages.format(
+ WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE_PREINIT, bcelTX.getClassName()) },
+ getSourceLocation(), new ISourceLocation[] { munger.getSourceLocation() });
+ // IMessage msg = new Message(
+ // WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE_DURING_AROUND_WEAVE_PREINIT,bcelTX.getClassName()),
+ // "",IMessage.ERROR,getSourceLocation(),null,
+ // new ISourceLocation[]{ munger.getSourceLocation()});
+ // world.getMessageHandler().handleMessage(msg);
+ }
+ stateTempVar.appendConvertableArrayLoad(returnConversionCode, fact, i, stateRTX);
}
} else {
- // pr226201
+ // pr226201
Member mungerSignature = munger.getSignature();
if (munger.getSignature() instanceof ResolvedMember) {
- if (((ResolvedMember)mungerSignature).hasBackingGenericMember()) {
- mungerSignature = ((ResolvedMember)mungerSignature).getBackingGenericMember();
+ if (((ResolvedMember) mungerSignature).hasBackingGenericMember()) {
+ mungerSignature = ((ResolvedMember) mungerSignature).getBackingGenericMember();
}
}
UnresolvedType returnType = mungerSignature.getReturnType();
- returnConversionCode =
- Utility.createConversion(
- getFactory(),
- BcelWorld.makeBcelType(returnType),
- callbackMethod.getReturnType(),world.isInJava5Mode());
+ returnConversionCode = Utility.createConversion(getFactory(), BcelWorld.makeBcelType(returnType), callbackMethod
+ .getReturnType(), world.isInJava5Mode());
if (!isFallsThrough()) {
- returnConversionCode.append(
- InstructionFactory.createReturn(callbackMethod.getReturnType()));
+ returnConversionCode.append(InstructionFactory.createReturn(callbackMethod.getReturnType()));
}
}
// initialize the bit flags for this shadow
- int bitflags =0x000000;
- if (getKind().isTargetSameAsThis()) bitflags|=0x010000;
- if (hasThis()) bitflags|=0x001000;
- if (bindsThis(munger)) bitflags|=0x000100;
- if (hasTarget()) bitflags|=0x000010;
- if (bindsTarget(munger)) bitflags|=0x000001;
-
- // ATAJ for @AJ aspect we need to link the closure with the joinpoint instance
- if (munger.getConcreteAspect()!=null && munger.getConcreteAspect().isAnnotationStyleAspect()
- && munger.getDeclaringAspect()!=null && munger.getDeclaringAspect().resolve(world).isAnnotationStyleAspect()) {
- // stick the bitflags on the stack and call the variant of linkClosureAndJoinPoint that takes an int
- closureInstantiation.append(fact.createConstant(Integer.valueOf(bitflags)));
- closureInstantiation.append(Utility.createInvoke(
- getFactory(),
- getWorld(),
- new MemberImpl(
- Member.METHOD,
- UnresolvedType.forName("org.aspectj.runtime.internal.AroundClosure"),
- Modifier.PUBLIC,
- "linkClosureAndJoinPoint",
- "(I)Lorg/aspectj/lang/ProceedingJoinPoint;"
- )
- ));
- }
-
- InstructionList advice = new InstructionList();
- advice.append(munger.getAdviceArgSetup(this, null, closureInstantiation));
-
- // invoke the advice
- advice.append(munger.getNonTestAdviceInstructions(this));
- advice.append(returnConversionCode);
- if (getKind()==Shadow.MethodExecution && linenumber>0) {
+ int bitflags = 0x000000;
+ if (getKind().isTargetSameAsThis())
+ bitflags |= 0x010000;
+ if (hasThis())
+ bitflags |= 0x001000;
+ if (bindsThis(munger))
+ bitflags |= 0x000100;
+ if (hasTarget())
+ bitflags |= 0x000010;
+ if (bindsTarget(munger))
+ bitflags |= 0x000001;
+
+ // ATAJ for @AJ aspect we need to link the closure with the joinpoint instance
+ if (munger.getConcreteAspect() != null && munger.getConcreteAspect().isAnnotationStyleAspect()
+ && munger.getDeclaringAspect() != null && munger.getDeclaringAspect().resolve(world).isAnnotationStyleAspect()) {
+ // stick the bitflags on the stack and call the variant of linkClosureAndJoinPoint that takes an int
+ closureInstantiation.append(fact.createConstant(Integer.valueOf(bitflags)));
+ closureInstantiation.append(Utility.createInvoke(getFactory(), getWorld(), new MemberImpl(Member.METHOD, UnresolvedType
+ .forName("org.aspectj.runtime.internal.AroundClosure"), Modifier.PUBLIC, "linkClosureAndJoinPoint",
+ "(I)Lorg/aspectj/lang/ProceedingJoinPoint;")));
+ }
+
+ InstructionList advice = new InstructionList();
+ advice.append(munger.getAdviceArgSetup(this, null, closureInstantiation));
+
+ // invoke the advice
+ advice.append(munger.getNonTestAdviceInstructions(this));
+ advice.append(returnConversionCode);
+ if (getKind() == Shadow.MethodExecution && linenumber > 0) {
advice.getStart().addTargeter(new LineNumberTag(linenumber));
}
-
+
if (!hasDynamicTest) {
range.append(advice);
} else {
InstructionList callback = makeCallToCallback(callbackMethod);
InstructionList postCallback = new InstructionList();
if (terminatesWithReturn()) {
- callback.append(
- InstructionFactory.createReturn(callbackMethod.getReturnType()));
+ callback.append(InstructionFactory.createReturn(callbackMethod.getReturnType()));
} else {
- advice.append(
- InstructionFactory.createBranchInstruction(
- Constants.GOTO,
- postCallback.append(InstructionConstants.NOP)));
+ advice.append(InstructionFactory.createBranchInstruction(Constants.GOTO, postCallback
+ .append(InstructionConstants.NOP)));
}
- range.append(
- munger.getTestInstructions(
- this,
- advice.getStart(),
- callback.getStart(),
- advice.getStart()));
+ range.append(munger.getTestInstructions(this, advice.getStart(), callback.getStart(), advice.getStart()));
range.append(advice);
range.append(callback);
range.append(postCallback);
}
- }
-
- // exposed for testing
- InstructionList makeCallToCallback(LazyMethodGen callbackMethod) {
- InstructionFactory fact = getFactory();
- InstructionList callback = new InstructionList();
- if (thisVar != null) {
- callback.append(InstructionConstants.ALOAD_0);
- }
- if (targetVar != null && targetVar != thisVar) {
- callback.append(BcelRenderer.renderExpr(fact, world, targetVar));
- }
- callback.append(BcelRenderer.renderExprs(fact, world, argVars));
- // remember to render tjps
- if (thisJoinPointVar != null) {
- callback.append(BcelRenderer.renderExpr(fact, world, thisJoinPointVar));
- }
- callback.append(Utility.createInvoke(fact, callbackMethod));
- return callback;
- }
+ }
+
+ // exposed for testing
+ InstructionList makeCallToCallback(LazyMethodGen callbackMethod) {
+ InstructionFactory fact = getFactory();
+ InstructionList callback = new InstructionList();
+ if (thisVar != null) {
+ callback.append(InstructionConstants.ALOAD_0);
+ }
+ if (targetVar != null && targetVar != thisVar) {
+ callback.append(BcelRenderer.renderExpr(fact, world, targetVar));
+ }
+ callback.append(BcelRenderer.renderExprs(fact, world, argVars));
+ // remember to render tjps
+ if (thisJoinPointVar != null) {
+ callback.append(BcelRenderer.renderExpr(fact, world, thisJoinPointVar));
+ }
+ callback.append(Utility.createInvoke(fact, callbackMethod));
+ return callback;
+ }
/** side-effect-free */
- private InstructionList makeClosureInstantiation(Member constructor, BcelVar holder) {
-
-// LazyMethodGen constructor) {
- InstructionFactory fact = getFactory();
- BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
- //final Type objectArrayType = new ArrayType(Type.OBJECT, 1);
- final InstructionList il = new InstructionList();
- int alen = getArgCount() + (thisVar == null ? 0 : 1) +
- ((targetVar != null && targetVar != thisVar) ? 1 : 0) +
- (thisJoinPointVar == null ? 0 : 1);
- il.append(Utility.createConstant(fact, alen));
- il.append(fact.createNewArray(Type.OBJECT, (short)1));
- arrayVar.appendStore(il, fact);
-
- int stateIndex = 0;
- if (thisVar != null) {
- arrayVar.appendConvertableArrayStore(il, fact, stateIndex, thisVar);
+ private InstructionList makeClosureInstantiation(Member constructor, BcelVar holder) {
+
+ // LazyMethodGen constructor) {
+ InstructionFactory fact = getFactory();
+ BcelVar arrayVar = genTempVar(UnresolvedType.OBJECTARRAY);
+ // final Type objectArrayType = new ArrayType(Type.OBJECT, 1);
+ final InstructionList il = new InstructionList();
+ int alen = getArgCount() + (thisVar == null ? 0 : 1) + ((targetVar != null && targetVar != thisVar) ? 1 : 0)
+ + (thisJoinPointVar == null ? 0 : 1);
+ il.append(Utility.createConstant(fact, alen));
+ il.append(fact.createNewArray(Type.OBJECT, (short) 1));
+ arrayVar.appendStore(il, fact);
+
+ int stateIndex = 0;
+ if (thisVar != null) {
+ arrayVar.appendConvertableArrayStore(il, fact, stateIndex, thisVar);
thisVar.setPositionInAroundState(stateIndex);
- stateIndex++;
- }
- if (targetVar != null && targetVar != thisVar) {
- arrayVar.appendConvertableArrayStore(il, fact, stateIndex, targetVar);
+ stateIndex++;
+ }
+ if (targetVar != null && targetVar != thisVar) {
+ arrayVar.appendConvertableArrayStore(il, fact, stateIndex, targetVar);
targetVar.setPositionInAroundState(stateIndex);
- stateIndex++;
- }
- for (int i = 0, len = getArgCount(); i<len; i++) {
- arrayVar.appendConvertableArrayStore(il, fact, stateIndex, argVars[i]);
- argVars[i].setPositionInAroundState(stateIndex);
- stateIndex++;
- }
- if (thisJoinPointVar != null) {
- arrayVar.appendConvertableArrayStore(il, fact, stateIndex, thisJoinPointVar);
- thisJoinPointVar.setPositionInAroundState(stateIndex);
- stateIndex++;
- }
- il.append(fact.createNew(new ObjectType(constructor.getDeclaringType().getName())));
- il.append(InstructionConstants.DUP);
- arrayVar.appendLoad(il, fact);
- il.append(Utility.createInvoke(fact, world, constructor));
- if (getKind() == PreInitialization) {
+ stateIndex++;
+ }
+ for (int i = 0, len = getArgCount(); i < len; i++) {
+ arrayVar.appendConvertableArrayStore(il, fact, stateIndex, argVars[i]);
+ argVars[i].setPositionInAroundState(stateIndex);
+ stateIndex++;
+ }
+ if (thisJoinPointVar != null) {
+ arrayVar.appendConvertableArrayStore(il, fact, stateIndex, thisJoinPointVar);
+ thisJoinPointVar.setPositionInAroundState(stateIndex);
+ stateIndex++;
+ }
+ il.append(fact.createNew(new ObjectType(constructor.getDeclaringType().getName())));
+ il.append(InstructionConstants.DUP);
+ arrayVar.appendLoad(il, fact);
+ il.append(Utility.createInvoke(fact, world, constructor));
+ if (getKind() == PreInitialization) {
il.append(InstructionConstants.DUP);
holder.appendStore(il, fact);
- }
- return il;
- }
-
-
- private IntMap makeProceedArgumentMap(BcelVar[] adviceArgs) {
- //System.err.println("coming in with " + Arrays.asList(adviceArgs));
-
- IntMap ret = new IntMap();
- for(int i = 0, len = adviceArgs.length; i < len; i++) {
- BcelVar v = adviceArgs[i];
- if (v == null) continue; // XXX we don't know why this is required
- int pos = v.getPositionInAroundState();
- if (pos >= 0) { // need this test to avoid args bound via cflow
- ret.put(pos, i);
- }
- }
- //System.err.println("returning " + ret);
-
- return ret;
- }
+ }
+ return il;
+ }
+
+ private IntMap makeProceedArgumentMap(BcelVar[] adviceArgs) {
+ // System.err.println("coming in with " + Arrays.asList(adviceArgs));
+
+ IntMap ret = new IntMap();
+ for (int i = 0, len = adviceArgs.length; i < len; i++) {
+ BcelVar v = adviceArgs[i];
+ if (v == null)
+ continue; // XXX we don't know why this is required
+ int pos = v.getPositionInAroundState();
+ if (pos >= 0) { // need this test to avoid args bound via cflow
+ ret.put(pos, i);
+ }
+ }
+ // System.err.println("returning " + ret);
+
+ return ret;
+ }
/**
*
*
* @param callbackMethod the method we will call back to when our run method gets called.
*
- * @param proceedMap A map from state position to proceed argument position. May be
- * non covering on state position.
+ * @param proceedMap A map from state position to proceed argument position. May be non covering on state position.
*/
- private LazyMethodGen makeClosureClassAndReturnConstructor(
- String closureClassName,
- LazyMethodGen callbackMethod,
- IntMap proceedMap)
- {
+ private LazyMethodGen makeClosureClassAndReturnConstructor(String closureClassName, LazyMethodGen callbackMethod,
+ IntMap proceedMap) {
String superClassName = "org.aspectj.runtime.internal.AroundClosure";
- Type objectArrayType = new ArrayType(Type.OBJECT, 1);
-
- LazyClassGen closureClass = new LazyClassGen(closureClassName,
- superClassName,
- getEnclosingClass().getFileName(),
- Modifier.PUBLIC,
- new String[] {},
- getWorld());
- InstructionFactory fact = new InstructionFactory(closureClass.getConstantPool());
-
- // constructor
- LazyMethodGen constructor = new LazyMethodGen(Modifier.PUBLIC,
- Type.VOID,
- "<init>",
- new Type[] {objectArrayType},
- new String[] {},
- closureClass);
- InstructionList cbody = constructor.getBody();
+ Type objectArrayType = new ArrayType(Type.OBJECT, 1);
+
+ LazyClassGen closureClass = new LazyClassGen(closureClassName, superClassName, getEnclosingClass().getFileName(),
+ Modifier.PUBLIC, new String[] {}, getWorld());
+ InstructionFactory fact = new InstructionFactory(closureClass.getConstantPool());
+
+ // constructor
+ LazyMethodGen constructor = new LazyMethodGen(Modifier.PUBLIC, Type.VOID, "<init>", new Type[] { objectArrayType },
+ new String[] {}, closureClass);
+ InstructionList cbody = constructor.getBody();
cbody.append(InstructionFactory.createLoad(Type.OBJECT, 0));
cbody.append(InstructionFactory.createLoad(objectArrayType, 1));
- cbody.append(fact.createInvoke(superClassName, "<init>", Type.VOID,
- new Type[] {objectArrayType}, Constants.INVOKESPECIAL));
+ cbody.append(fact
+ .createInvoke(superClassName, "<init>", Type.VOID, new Type[] { objectArrayType }, Constants.INVOKESPECIAL));
cbody.append(InstructionFactory.createReturn(Type.VOID));
- closureClass.addMethodGen(constructor);
-
- // method
- LazyMethodGen runMethod = new LazyMethodGen(Modifier.PUBLIC,
- Type.OBJECT,
- "run",
- new Type[] {objectArrayType},
- new String[] {},
- closureClass);
- InstructionList mbody = runMethod.getBody();
- BcelVar proceedVar = new BcelVar(UnresolvedType.OBJECTARRAY.resolve(world), 1);
- // int proceedVarIndex = 1;
- BcelVar stateVar =
- new BcelVar(UnresolvedType.OBJECTARRAY.resolve(world), runMethod.allocateLocal(1));
- // int stateVarIndex = runMethod.allocateLocal(1);
+ closureClass.addMethodGen(constructor);
+
+ // method
+ LazyMethodGen runMethod = new LazyMethodGen(Modifier.PUBLIC, Type.OBJECT, "run", new Type[] { objectArrayType },
+ new String[] {}, closureClass);
+ InstructionList mbody = runMethod.getBody();
+ BcelVar proceedVar = new BcelVar(UnresolvedType.OBJECTARRAY.resolve(world), 1);
+ // int proceedVarIndex = 1;
+ BcelVar stateVar = new BcelVar(UnresolvedType.OBJECTARRAY.resolve(world), runMethod.allocateLocal(1));
+ // int stateVarIndex = runMethod.allocateLocal(1);
mbody.append(InstructionFactory.createThis());
mbody.append(fact.createGetField(superClassName, "state", objectArrayType));
- mbody.append(stateVar.createStore(fact));
- // mbody.append(fact.createStore(objectArrayType, stateVarIndex));
-
- Type[] stateTypes = callbackMethod.getArgumentTypes();
-
- for (int i=0, len=stateTypes.length; i < len; i++) {
- Type stateType = stateTypes[i];
- ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
- if (proceedMap.hasKey(i)) {
- mbody.append(
- proceedVar.createConvertableArrayLoad(fact, proceedMap.get(i),
- stateTypeX));
- } else {
- mbody.append(
- stateVar.createConvertableArrayLoad(fact, i,
- stateTypeX));
- }
- }
-
-
+ mbody.append(stateVar.createStore(fact));
+ // mbody.append(fact.createStore(objectArrayType, stateVarIndex));
+
+ Type[] stateTypes = callbackMethod.getArgumentTypes();
+
+ for (int i = 0, len = stateTypes.length; i < len; i++) {
+ Type stateType = stateTypes[i];
+ ResolvedType stateTypeX = BcelWorld.fromBcel(stateType).resolve(world);
+ if (proceedMap.hasKey(i)) {
+ mbody.append(proceedVar.createConvertableArrayLoad(fact, proceedMap.get(i), stateTypeX));
+ } else {
+ mbody.append(stateVar.createConvertableArrayLoad(fact, i, stateTypeX));
+ }
+ }
+
mbody.append(Utility.createInvoke(fact, callbackMethod));
-
+
if (getKind() == PreInitialization) {
- mbody.append(Utility.createSet(
- fact,
- AjcMemberMaker.aroundClosurePreInitializationField()));
+ mbody.append(Utility.createSet(fact, AjcMemberMaker.aroundClosurePreInitializationField()));
mbody.append(InstructionConstants.ACONST_NULL);
} else {
- mbody.append(
- Utility.createConversion(
- fact,
- callbackMethod.getReturnType(),
- Type.OBJECT));
+ mbody.append(Utility.createConversion(fact, callbackMethod.getReturnType(), Type.OBJECT));
}
mbody.append(InstructionFactory.createReturn(Type.OBJECT));
closureClass.addMethodGen(runMethod);
-
+
// class
getEnclosingClass().addGeneratedInner(closureClass);
-
+
return constructor;
}
-
- // ---- extraction methods
-
- public LazyMethodGen extractMethod(String newMethodName, int visibilityModifier, ShadowMunger munger) {
+ // ---- extraction methods
+
+ public LazyMethodGen extractMethod(String newMethodName, int visibilityModifier, ShadowMunger munger) {
LazyMethodGen.assertGoodBody(range.getBody(), newMethodName);
- if (!getKind().allowsExtraction()) throw new BCException("Attempt to extract method from a shadow kind that does not support this operation (" + getKind() + ")");
- LazyMethodGen freshMethod = createMethodGen(newMethodName,visibilityModifier);
-
-// System.err.println("******");
-// System.err.println("ABOUT TO EXTRACT METHOD for" + this);
-// enclosingMethod.print(System.err);
-// System.err.println("INTO");
-// freshMethod.print(System.err);
-// System.err.println("WITH REMAP");
-// System.err.println(makeRemap());
-
- range.extractInstructionsInto(freshMethod, makeRemap(),
- (getKind() != PreInitialization) &&
- isFallsThrough());
- if (getKind() == PreInitialization) {
- addPreInitializationReturnCode(
- freshMethod,
- getSuperConstructorParameterTypes());
- }
- getEnclosingClass().addMethodGen(freshMethod,munger.getSourceLocation());
-
- return freshMethod;
- }
-
- private void addPreInitializationReturnCode(
- LazyMethodGen extractedMethod,
- Type[] superConstructorTypes)
- {
+ if (!getKind().allowsExtraction())
+ throw new BCException("Attempt to extract method from a shadow kind that does not support this operation (" + getKind()
+ + ")");
+ LazyMethodGen freshMethod = createMethodGen(newMethodName, visibilityModifier);
+
+ // System.err.println("******");
+ // System.err.println("ABOUT TO EXTRACT METHOD for" + this);
+ // enclosingMethod.print(System.err);
+ // System.err.println("INTO");
+ // freshMethod.print(System.err);
+ // System.err.println("WITH REMAP");
+ // System.err.println(makeRemap());
+
+ range.extractInstructionsInto(freshMethod, makeRemap(), (getKind() != PreInitialization) && isFallsThrough());
+ if (getKind() == PreInitialization) {
+ addPreInitializationReturnCode(freshMethod, getSuperConstructorParameterTypes());
+ }
+ getEnclosingClass().addMethodGen(freshMethod, munger.getSourceLocation());
+
+ return freshMethod;
+ }
+
+ private void addPreInitializationReturnCode(LazyMethodGen extractedMethod, Type[] superConstructorTypes) {
InstructionList body = extractedMethod.getBody();
- final InstructionFactory fact = getFactory();
-
- BcelVar arrayVar = new BcelVar(
- world.getCoreType(UnresolvedType.OBJECTARRAY),
- extractedMethod.allocateLocal(1));
-
+ final InstructionFactory fact = getFactory();
+
+ BcelVar arrayVar = new BcelVar(world.getCoreType(UnresolvedType.OBJECTARRAY), extractedMethod.allocateLocal(1));
+
int len = superConstructorTypes.length;
-
- body.append(Utility.createConstant(fact, len));
- body.append(fact.createNewArray(Type.OBJECT, (short)1));
- arrayVar.appendStore(body, fact);
+ body.append(Utility.createConstant(fact, len));
- for (int i = len - 1; i >= 0; i++) {
- // convert thing on top of stack to object
- body.append(
- Utility.createConversion(fact, superConstructorTypes[i], Type.OBJECT));
+ body.append(fact.createNewArray(Type.OBJECT, (short) 1));
+ arrayVar.appendStore(body, fact);
+
+ for (int i = len - 1; i >= 0; i++) {
+ // convert thing on top of stack to object
+ body.append(Utility.createConversion(fact, superConstructorTypes[i], Type.OBJECT));
// push object array
arrayVar.appendLoad(body, fact);
// swap
body.append(InstructionConstants.SWAP);
- // do object array store.
+ // do object array store.
body.append(Utility.createConstant(fact, i));
body.append(InstructionConstants.SWAP);
body.append(InstructionFactory.createArrayStore(Type.OBJECT));
- }
- arrayVar.appendLoad(body, fact);
- body.append(InstructionConstants.ARETURN);
+ }
+ arrayVar.appendLoad(body, fact);
+ body.append(InstructionConstants.ARETURN);
}
private Type[] getSuperConstructorParameterTypes() {
- // assert getKind() == PreInitialization
+ // assert getKind() == PreInitialization
InstructionHandle superCallHandle = getRange().getEnd().getNext();
- InvokeInstruction superCallInstruction =
- (InvokeInstruction) superCallHandle.getInstruction();
- return superCallInstruction.getArgumentTypes(
- getEnclosingClass().getConstantPool());
+ InvokeInstruction superCallInstruction = (InvokeInstruction) superCallHandle.getInstruction();
+ return superCallInstruction.getArgumentTypes(getEnclosingClass().getConstantPool());
}
-
- /** make a map from old frame location to new frame location. Any unkeyed frame
- * location picks out a copied local */
- private IntMap makeRemap() {
- IntMap ret = new IntMap(5);
- int reti = 0;
+ /**
+ * make a map from old frame location to new frame location. Any unkeyed frame location picks out a copied local
+ */
+ private IntMap makeRemap() {
+ IntMap ret = new IntMap(5);
+ int reti = 0;
if (thisVar != null) {
- ret.put(0, reti++); // thisVar guaranteed to be 0
- }
- if (targetVar != null && targetVar != thisVar) {
- ret.put(targetVar.getSlot(), reti++);
- }
- for (int i = 0, len = argVars.length; i < len; i++) {
- ret.put(argVars[i].getSlot(), reti);
- reti += argVars[i].getType().getSize();
- }
- if (thisJoinPointVar != null) {
- ret.put(thisJoinPointVar.getSlot(), reti++);
- }
- // we not only need to put the arguments, we also need to remap their
- // aliases, which we so helpfully put into temps at the beginning of this join
- // point.
- if (! getKind().argsOnStack()) {
- int oldi = 0;
- int newi = 0;
- // if we're passing in a this and we're not argsOnStack we're always
- // passing in a target too
- if (arg0HoldsThis()) { ret.put(0, 0); oldi++; newi+=1; }
- //assert targetVar == thisVar
- for (int i = 0; i < getArgCount(); i++) {
- UnresolvedType type = getArgType(i);
+ ret.put(0, reti++); // thisVar guaranteed to be 0
+ }
+ if (targetVar != null && targetVar != thisVar) {
+ ret.put(targetVar.getSlot(), reti++);
+ }
+ for (int i = 0, len = argVars.length; i < len; i++) {
+ ret.put(argVars[i].getSlot(), reti);
+ reti += argVars[i].getType().getSize();
+ }
+ if (thisJoinPointVar != null) {
+ ret.put(thisJoinPointVar.getSlot(), reti++);
+ }
+ // we not only need to put the arguments, we also need to remap their
+ // aliases, which we so helpfully put into temps at the beginning of this join
+ // point.
+ if (!getKind().argsOnStack()) {
+ int oldi = 0;
+ int newi = 0;
+ // if we're passing in a this and we're not argsOnStack we're always
+ // passing in a target too
+ if (arg0HoldsThis()) {
+ ret.put(0, 0);
+ oldi++;
+ newi += 1;
+ }
+ // assert targetVar == thisVar
+ for (int i = 0; i < getArgCount(); i++) {
+ UnresolvedType type = getArgType(i);
ret.put(oldi, newi);
- oldi += type.getSize();
- newi += type.getSize();
- }
- }
-
-// System.err.println("making remap for : " + this);
-// if (targetVar != null) System.err.println("target slot : " + targetVar.getSlot());
-// if (thisVar != null) System.err.println(" this slot : " + thisVar.getSlot());
-// System.err.println(ret);
-
- return ret;
- }
-
- /**
- * The new method always static.
- * It may take some extra arguments: this, target.
- * If it's argsOnStack, then it must take both this/target
- * If it's argsOnFrame, it shares this and target.
- * ??? rewrite this to do less array munging, please
- */
- private LazyMethodGen createMethodGen(String newMethodName, int visibilityModifier) {
- Type[] parameterTypes = BcelWorld.makeBcelTypes(getArgTypes());
- int modifiers = Modifier.FINAL | visibilityModifier;
-
- // XXX some bug
-// if (! isExpressionKind() && getSignature().isStrict(world)) {
-// modifiers |= Modifier.STRICT;
-// }
- modifiers |= Modifier.STATIC;
- if (targetVar != null && targetVar != thisVar) {
- UnresolvedType targetType = getTargetType();
- targetType = ensureTargetTypeIsCorrect(targetType);
- // see pr109728,pr229910 - this fixes the case when the declaring class is sometype 'X' but the (gs)etfield
- // in the bytecode refers to a subtype of 'X'. This makes sure we use the type originally
- // mentioned in the fieldget instruction as the method parameter and *not* the type upon which the
- // field is declared because when the instructions are extracted into the new around body,
- // they will still refer to the subtype.
- if ((getKind()==FieldGet || getKind()==FieldSet) && getActualTargetType()!=null &&
- !getActualTargetType().equals(targetType.getName())) {
- targetType = UnresolvedType.forName(getActualTargetType()).resolve(world);
- }
- ResolvedMember resolvedMember = getSignature().resolve(world);
-
- // pr230075, pr197719
- if (resolvedMember != null && Modifier.isProtected(resolvedMember.getModifiers()) &&
- !samePackage(resolvedMember.getDeclaringType().getPackageName(), getEnclosingType().getPackageName()) &&
- !resolvedMember.getName().equals("clone"))
- {
- if (!hasThis()) { // pr197719 - static accessor has been created to handle the call
- if (Modifier.isStatic(enclosingMethod.getAccessFlags()) && enclosingMethod.getName().startsWith("access$")) {
- targetType = BcelWorld.fromBcel(enclosingMethod.getArgumentTypes()[0]);
- }
- } else {
- if (!targetType.resolve(world).isAssignableFrom(getThisType().resolve(world))) {
- throw new BCException("bad bytecode");
- }
- targetType = getThisType();
- }
- }
- parameterTypes = addType(BcelWorld.makeBcelType(targetType), parameterTypes);
- }
- if (thisVar != null) {
- UnresolvedType thisType = getThisType();
- parameterTypes = addType(BcelWorld.makeBcelType(thisType), parameterTypes);
- }
-
- // We always want to pass down thisJoinPoint in case we have already woven
- // some advice in here. If we only have a single piece of around advice on a
- // join point, it is unnecessary to accept (and pass) tjp.
- if (thisJoinPointVar != null) {
- parameterTypes = addTypeToEnd(LazyClassGen.tjpType, parameterTypes);
- //FIXME ALEX? which one
- //parameterTypes = addTypeToEnd(LazyClassGen.proceedingTjpType, parameterTypes);
- }
-
- UnresolvedType returnType;
- if (getKind() == PreInitialization) {
- returnType = UnresolvedType.OBJECTARRAY;
- } else {
-
- if (getKind() == ConstructorCall) returnType = getSignature().getDeclaringType();
- else if (getKind() == FieldSet) returnType = ResolvedType.VOID;
- else returnType = getSignature().getReturnType().resolve(world);
-// returnType = getReturnType(); // for this and above lines, see pr137496
- }
- return
- new LazyMethodGen(
- modifiers,
- BcelWorld.makeBcelType(returnType),
- newMethodName,
- parameterTypes,
- new String[0],
- // XXX again, we need to look up methods!
-// UnresolvedType.getNames(getSignature().getExceptions(world)),
- getEnclosingClass());
- }
+ oldi += type.getSize();
+ newi += type.getSize();
+ }
+ }
+
+ // System.err.println("making remap for : " + this);
+ // if (targetVar != null) System.err.println("target slot : " + targetVar.getSlot());
+ // if (thisVar != null) System.err.println(" this slot : " + thisVar.getSlot());
+ // System.err.println(ret);
+
+ return ret;
+ }
+
+ /**
+ * The new method always static. It may take some extra arguments: this, target. If it's argsOnStack, then it must take both
+ * this/target If it's argsOnFrame, it shares this and target. ??? rewrite this to do less array munging, please
+ */
+ private LazyMethodGen createMethodGen(String newMethodName, int visibilityModifier) {
+ Type[] parameterTypes = BcelWorld.makeBcelTypes(getArgTypes());
+ int modifiers = Modifier.FINAL | visibilityModifier;
+
+ // XXX some bug
+ // if (! isExpressionKind() && getSignature().isStrict(world)) {
+ // modifiers |= Modifier.STRICT;
+ // }
+ modifiers |= Modifier.STATIC;
+ if (targetVar != null && targetVar != thisVar) {
+ UnresolvedType targetType = getTargetType();
+ targetType = ensureTargetTypeIsCorrect(targetType);
+ // see pr109728,pr229910 - this fixes the case when the declaring class is sometype 'X' but the (gs)etfield
+ // in the bytecode refers to a subtype of 'X'. This makes sure we use the type originally
+ // mentioned in the fieldget instruction as the method parameter and *not* the type upon which the
+ // field is declared because when the instructions are extracted into the new around body,
+ // they will still refer to the subtype.
+ if ((getKind() == FieldGet || getKind() == FieldSet) && getActualTargetType() != null
+ && !getActualTargetType().equals(targetType.getName())) {
+ targetType = UnresolvedType.forName(getActualTargetType()).resolve(world);
+ }
+ ResolvedMember resolvedMember = getSignature().resolve(world);
+
+ // pr230075, pr197719
+ if (resolvedMember != null && Modifier.isProtected(resolvedMember.getModifiers())
+ && !samePackage(resolvedMember.getDeclaringType().getPackageName(), getEnclosingType().getPackageName())
+ && !resolvedMember.getName().equals("clone")) {
+ if (!hasThis()) { // pr197719 - static accessor has been created to handle the call
+ if (Modifier.isStatic(enclosingMethod.getAccessFlags()) && enclosingMethod.getName().startsWith("access$")) {
+ targetType = BcelWorld.fromBcel(enclosingMethod.getArgumentTypes()[0]);
+ }
+ } else {
+ if (!targetType.resolve(world).isAssignableFrom(getThisType().resolve(world))) {
+ throw new BCException("bad bytecode");
+ }
+ targetType = getThisType();
+ }
+ }
+ parameterTypes = addType(BcelWorld.makeBcelType(targetType), parameterTypes);
+ }
+ if (thisVar != null) {
+ UnresolvedType thisType = getThisType();
+ parameterTypes = addType(BcelWorld.makeBcelType(thisType), parameterTypes);
+ }
+
+ // We always want to pass down thisJoinPoint in case we have already woven
+ // some advice in here. If we only have a single piece of around advice on a
+ // join point, it is unnecessary to accept (and pass) tjp.
+ if (thisJoinPointVar != null) {
+ parameterTypes = addTypeToEnd(LazyClassGen.tjpType, parameterTypes);
+ // FIXME ALEX? which one
+ // parameterTypes = addTypeToEnd(LazyClassGen.proceedingTjpType, parameterTypes);
+ }
+
+ UnresolvedType returnType;
+ if (getKind() == PreInitialization) {
+ returnType = UnresolvedType.OBJECTARRAY;
+ } else {
+
+ if (getKind() == ConstructorCall)
+ returnType = getSignature().getDeclaringType();
+ else if (getKind() == FieldSet)
+ returnType = ResolvedType.VOID;
+ else
+ returnType = getSignature().getReturnType().resolve(world);
+ // returnType = getReturnType(); // for this and above lines, see pr137496
+ }
+ return new LazyMethodGen(modifiers, BcelWorld.makeBcelType(returnType), newMethodName, parameterTypes, new String[0],
+ // XXX again, we need to look up methods!
+ // UnresolvedType.getNames(getSignature().getExceptions(world)),
+ getEnclosingClass());
+ }
private boolean samePackage(String p1, String p2) {
- if (p1 == null) return p2 == null;
- if (p2 == null) return false;
+ if (p1 == null)
+ return p2 == null;
+ if (p2 == null)
+ return false;
return p1.equals(p2);
}
-
- private Type[] addType(Type type, Type[] types) {
- int len = types.length;
- Type[] ret = new Type[len+1];
- ret[0] = type;
- System.arraycopy(types, 0, ret, 1, len);
- return ret;
- }
-
- private Type[] addTypeToEnd(Type type, Type[] types) {
- int len = types.length;
- Type[] ret = new Type[len+1];
- ret[len] = type;
- System.arraycopy(types, 0, ret, 0, len);
- return ret;
- }
-
- public BcelVar genTempVar(UnresolvedType typeX) {
- return new BcelVar(typeX.resolve(world), genTempVarIndex(typeX.getSize()));
- }
-
-// public static final boolean CREATE_TEMP_NAMES = true;
-
- public BcelVar genTempVar(UnresolvedType typeX, String localName) {
+ private Type[] addType(Type type, Type[] types) {
+ int len = types.length;
+ Type[] ret = new Type[len + 1];
+ ret[0] = type;
+ System.arraycopy(types, 0, ret, 1, len);
+ return ret;
+ }
+
+ private Type[] addTypeToEnd(Type type, Type[] types) {
+ int len = types.length;
+ Type[] ret = new Type[len + 1];
+ ret[len] = type;
+ System.arraycopy(types, 0, ret, 0, len);
+ return ret;
+ }
+
+ public BcelVar genTempVar(UnresolvedType typeX) {
+ return new BcelVar(typeX.resolve(world), genTempVarIndex(typeX.getSize()));
+ }
+
+ // public static final boolean CREATE_TEMP_NAMES = true;
+
+ public BcelVar genTempVar(UnresolvedType typeX, String localName) {
BcelVar tv = genTempVar(typeX);
-// if (CREATE_TEMP_NAMES) {
-// for (InstructionHandle ih = range.getStart(); ih != range.getEnd(); ih = ih.getNext()) {
-// if (Range.isRangeHandle(ih)) continue;
-// ih.addTargeter(new LocalVariableTag(typeX, localName, tv.getSlot()));
-// }
-// }
+ // if (CREATE_TEMP_NAMES) {
+ // for (InstructionHandle ih = range.getStart(); ih != range.getEnd(); ih = ih.getNext()) {
+ // if (Range.isRangeHandle(ih)) continue;
+ // ih.addTargeter(new LocalVariableTag(typeX, localName, tv.getSlot()));
+ // }
+ // }
return tv;
- }
-
- // eh doesn't think we need to garbage collect these (64K is a big number...)
- private int genTempVarIndex(int size) {
- return enclosingMethod.allocateLocal(size);
- }
-
- public InstructionFactory getFactory() {
- return getEnclosingClass().getFactory();
- }
-
+ }
+
+ // eh doesn't think we need to garbage collect these (64K is a big number...)
+ private int genTempVarIndex(int size) {
+ return enclosingMethod.allocateLocal(size);
+ }
+
+ public InstructionFactory getFactory() {
+ return getEnclosingClass().getFactory();
+ }
+
public ISourceLocation getSourceLocation() {
int sourceLine = getSourceLine();
if (sourceLine == 0 || sourceLine == -1) {
-// Thread.currentThread().dumpStack();
-// System.err.println(this + ": " + range);
+ // Thread.currentThread().dumpStack();
+ // System.err.println(this + ": " + range);
return getEnclosingClass().getType().getSourceLocation();
} else {
- // For staticinitialization, if we have a nice offset, don't build a new source loc
- if (getKind()==Shadow.StaticInitialization && getEnclosingClass().getType().getSourceLocation().getOffset()!=0) {
+ // For staticinitialization, if we have a nice offset, don't build a new source loc
+ if (getKind() == Shadow.StaticInitialization && getEnclosingClass().getType().getSourceLocation().getOffset() != 0) {
return getEnclosingClass().getType().getSourceLocation();
} else {
int offset = 0;
Kind kind = getKind();
- if ( (kind == MethodExecution) ||
- (kind == ConstructorExecution) ||
- (kind == AdviceExecution) ||
- (kind == StaticInitialization) ||
- (kind == PreInitialization) ||
- (kind == Initialization)) {
- if (getEnclosingMethod().hasDeclaredLineNumberInfo()) {
- offset = getEnclosingMethod().getDeclarationOffset();
- }
- }
- return getEnclosingClass().getType().getSourceContext().makeSourceLocation(sourceLine, offset);
+ if ((kind == MethodExecution) || (kind == ConstructorExecution) || (kind == AdviceExecution)
+ || (kind == StaticInitialization) || (kind == PreInitialization) || (kind == Initialization)) {
+ if (getEnclosingMethod().hasDeclaredLineNumberInfo()) {
+ offset = getEnclosingMethod().getDeclarationOffset();
+ }
+ }
+ return getEnclosingClass().getType().getSourceContext().makeSourceLocation(sourceLine, offset);
}
}
}
public void setActualTargetType(String className) {
this.actualInstructionTargetType = className;
}
-
+
public String getActualTargetType() {
return actualInstructionTargetType;
}
projects / aspectj.git / commitdiff