| /* ******************************************************************* |
| * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC). |
| * All rights reserved. |
| * This program and the accompanying materials are made available |
| * under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * PARC initial implementation |
| * Alexandre Vasseur @AspectJ ITDs |
| * ******************************************************************/ |
| |
| package org.aspectj.weaver; |
| |
| import java.lang.reflect.Modifier; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Queue; |
| import java.util.Set; |
| |
| import org.aspectj.bridge.IMessage; |
| import org.aspectj.bridge.ISourceLocation; |
| import org.aspectj.bridge.Message; |
| import org.aspectj.bridge.MessageUtil; |
| import org.aspectj.util.FuzzyBoolean; |
| import org.aspectj.weaver.AjAttribute.WeaverVersionInfo; |
| import org.aspectj.weaver.Iterators.Getter; |
| import org.aspectj.weaver.patterns.Declare; |
| import org.aspectj.weaver.patterns.PerClause; |
| |
| public abstract class ResolvedType extends UnresolvedType implements AnnotatedElement { |
| |
| public static final ResolvedType[] EMPTY_RESOLVED_TYPE_ARRAY = new ResolvedType[0]; |
| public static final String PARAMETERIZED_TYPE_IDENTIFIER = "P"; |
| |
| // Set temporarily 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 int bits; |
| |
| private static int AnnotationBitsInitialized = 0x0001; |
| private static int AnnotationMarkedInherited = 0x0002; |
| private static int MungersAnalyzed = 0x0004; |
| private static int HasParentMunger = 0x0008; |
| private static int TypeHierarchyCompleteBit = 0x0010; |
| private static int GroovyObjectInitialized = 0x0020; |
| private static int IsGroovyObject = 0x0040; |
| |
| 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; |
| } |
| |
| public int getSize() { |
| return 1; |
| } |
| |
| /** |
| * 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<ResolvedType> getDirectSupertypes() { |
| Iterator<ResolvedType> interfacesIterator = Iterators.array(getDeclaredInterfaces()); |
| ResolvedType superclass = getSuperclass(); |
| if (superclass == null) { |
| return interfacesIterator; |
| } else { |
| return Iterators.snoc(interfacesIterator, superclass); |
| } |
| } |
| |
| public abstract ResolvedMember[] getDeclaredFields(); |
| |
| public abstract ResolvedMember[] getDeclaredMethods(); |
| |
| public abstract ResolvedType[] getDeclaredInterfaces(); |
| |
| public abstract ResolvedMember[] getDeclaredPointcuts(); |
| |
| public boolean isCacheable() { |
| return true; |
| } |
| |
| /** |
| * @return the superclass of this type, or null (if this represents a jlObject, primitive, or void) |
| */ |
| public abstract ResolvedType getSuperclass(); |
| |
| 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 AnnotationAJ 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<String> validBoxing = new HashSet<String>(); |
| |
| 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 |
| |
| @Override |
| public 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<ResolvedMember> getFields() { |
| final Iterators.Filter<ResolvedType> dupFilter = Iterators.dupFilter(); |
| Iterators.Getter<ResolvedType, ResolvedType> typeGetter = new Iterators.Getter<ResolvedType, ResolvedType>() { |
| public Iterator<ResolvedType> get(ResolvedType o) { |
| return dupFilter.filter(o.getDirectSupertypes()); |
| } |
| }; |
| return Iterators.mapOver(Iterators.recur(this, typeGetter), FieldGetterInstance); |
| } |
| |
| /** |
| * 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 (but those 'closest' to this type are first)</li> |
| * </ul> |
| * <p/> |
| * |
| * @param wantGenerics is true if the caller would like all generics information, otherwise those methods are collapsed to their |
| * erasure |
| */ |
| public Iterator<ResolvedMember> getMethods(boolean wantGenerics, boolean wantDeclaredParents) { |
| return Iterators.mapOver(getHierarchy(wantGenerics, wantDeclaredParents), MethodGetterInstance); |
| } |
| |
| public Iterator<ResolvedMember> getMethodsIncludingIntertypeDeclarations(boolean wantGenerics, boolean wantDeclaredParents) { |
| return Iterators.mapOver(getHierarchy(wantGenerics, wantDeclaredParents), MethodGetterWithItdsInstance); |
| } |
| |
| /** |
| * An Iterators.Getter that returns an iterator over all methods declared on some resolved type. |
| */ |
| private static class MethodGetter implements Iterators.Getter<ResolvedType, ResolvedMember> { |
| public Iterator<ResolvedMember> get(ResolvedType type) { |
| return Iterators.array(type.getDeclaredMethods()); |
| } |
| } |
| |
| /** |
| * An Iterators.Getter that returns an iterator over all pointcuts declared on some resolved type. |
| */ |
| private static class PointcutGetter implements Iterators.Getter<ResolvedType, ResolvedMember> { |
| public Iterator<ResolvedMember> get(ResolvedType o) { |
| return Iterators.array(o.getDeclaredPointcuts()); |
| } |
| } |
| |
| // OPTIMIZE could cache the result of discovering ITDs |
| |
| // Getter that returns all declared methods for a type through an iterator - including intertype declarations |
| private static class MethodGetterIncludingItds implements Iterators.Getter<ResolvedType, ResolvedMember> { |
| public Iterator<ResolvedMember> get(ResolvedType type) { |
| ResolvedMember[] methods = type.getDeclaredMethods(); |
| if (type.interTypeMungers != null) { |
| int additional = 0; |
| for (ConcreteTypeMunger typeTransformer : type.interTypeMungers) { |
| ResolvedMember rm = typeTransformer.getSignature(); |
| // BUG won't this include fields? When we are looking for methods |
| if (rm != null) { // new parent type munger can have null signature |
| additional++; |
| } |
| } |
| if (additional > 0) { |
| ResolvedMember[] methods2 = new ResolvedMember[methods.length + additional]; |
| System.arraycopy(methods, 0, methods2, 0, methods.length); |
| additional = methods.length; |
| for (ConcreteTypeMunger typeTransformer : type.interTypeMungers) { |
| ResolvedMember rm = typeTransformer.getSignature(); |
| if (rm != null) { // new parent type munger can have null signature |
| methods2[additional++] = typeTransformer.getSignature(); |
| } |
| } |
| methods = methods2; |
| } |
| } |
| return Iterators.array(methods); |
| } |
| } |
| |
| /** |
| * An Iterators.Getter that returns an iterator over all fields declared on some resolved type. |
| */ |
| private static class FieldGetter implements Iterators.Getter<ResolvedType, ResolvedMember> { |
| public Iterator<ResolvedMember> get(ResolvedType type) { |
| return Iterators.array(type.getDeclaredFields()); |
| } |
| } |
| |
| private final static MethodGetter MethodGetterInstance = new MethodGetter(); |
| private final static MethodGetterIncludingItds MethodGetterWithItdsInstance = new MethodGetterIncludingItds(); |
| private final static PointcutGetter PointcutGetterInstance = new PointcutGetter(); |
| private final static FieldGetter FieldGetterInstance = new FieldGetter(); |
| |
| /** |
| * Return an iterator over the types in this types hierarchy - starting with this type first, then all superclasses up to Object |
| * and then all interfaces (starting with those 'nearest' this type). |
| * |
| * @param wantGenerics true if the caller wants full generic information |
| * @param wantDeclaredParents true if the caller even wants those parents introduced via declare parents |
| * @return an iterator over all types in the hierarchy of this type |
| */ |
| public Iterator<ResolvedType> getHierarchy() { |
| return getHierarchy(false, false); |
| } |
| |
| public Iterator<ResolvedType> getHierarchy(final boolean wantGenerics, final boolean wantDeclaredParents) { |
| |
| final Iterators.Getter<ResolvedType, ResolvedType> interfaceGetter = new Iterators.Getter<ResolvedType, ResolvedType>() { |
| List<String> alreadySeen = new ArrayList<String>(); // Strings are signatures (ResolvedType.getSignature()) |
| |
| public Iterator<ResolvedType> get(ResolvedType type) { |
| ResolvedType[] interfaces = type.getDeclaredInterfaces(); |
| |
| // remove interfaces introduced by declare parents |
| // relatively expensive but hopefully uncommon |
| if (!wantDeclaredParents && type.hasNewParentMungers()) { |
| // Throw away interfaces from that array if they were decp'd onto here |
| List<Integer> forRemoval = new ArrayList<Integer>(); |
| for (ConcreteTypeMunger munger : type.interTypeMungers) { |
| if (munger.getMunger() != null) { |
| ResolvedTypeMunger m = munger.getMunger(); |
| if (m.getKind() == ResolvedTypeMunger.Parent) { |
| ResolvedType newType = ((NewParentTypeMunger) m).getNewParent(); |
| if (!wantGenerics && newType.isParameterizedOrGenericType()) { |
| newType = newType.getRawType(); |
| } |
| for (int ii = 0; ii < interfaces.length; ii++) { |
| ResolvedType iface = interfaces[ii]; |
| if (!wantGenerics && iface.isParameterizedOrGenericType()) { |
| iface = iface.getRawType(); |
| } |
| if (newType.getSignature().equals(iface.getSignature())) { // pr171953 |
| forRemoval.add(ii); |
| } |
| } |
| } |
| } |
| } |
| // Found some to remove from those we are going to iterate over |
| if (forRemoval.size() > 0) { |
| ResolvedType[] interfaces2 = new ResolvedType[interfaces.length - forRemoval.size()]; |
| int p = 0; |
| for (int ii = 0; ii < interfaces.length; ii++) { |
| if (!forRemoval.contains(ii)) { |
| interfaces2[p++] = interfaces[ii]; |
| } |
| } |
| interfaces = interfaces2; |
| } |
| } |
| return new Iterators.ResolvedTypeArrayIterator(interfaces, alreadySeen, wantGenerics); |
| } |
| }; |
| |
| // If this type is an interface, there are only interfaces to walk |
| if (this.isInterface()) { |
| return new SuperInterfaceWalker(interfaceGetter, this); |
| } else { |
| SuperInterfaceWalker superInterfaceWalker = new SuperInterfaceWalker(interfaceGetter); |
| Iterator<ResolvedType> superClassesIterator = new SuperClassWalker(this, superInterfaceWalker, wantGenerics); |
| // append() will check if the second iterator is empty before appending - but the types which the superInterfaceWalker |
| // needs to visit are only accumulated whilst the superClassesIterator is in progress |
| return Iterators.append1(superClassesIterator, superInterfaceWalker); |
| } |
| } |
| |
| /** |
| * 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. This is expensive - use the getMethods() method if you can! |
| */ |
| public List<ResolvedMember> getMethodsWithoutIterator(boolean includeITDs, boolean allowMissing, boolean genericsAware) { |
| List<ResolvedMember> methods = new ArrayList<ResolvedMember>(); |
| Set<String> knowninterfaces = new HashSet<String>(); |
| addAndRecurse(knowninterfaces, methods, this, includeITDs, allowMissing, genericsAware); |
| return methods; |
| } |
| |
| /** |
| * Return a list of the types in the hierarchy of this type, starting with this type. The order in the list is the superclasses |
| * followed by the super interfaces. |
| * |
| * @param genericsAware should the list include parameterized/generic types (if not, they will be collapsed to raw)? |
| * @return list of resolvedtypes in this types hierarchy, including this type first |
| */ |
| public List<ResolvedType> getHierarchyWithoutIterator(boolean includeITDs, boolean allowMissing, boolean genericsAware) { |
| List<ResolvedType> types = new ArrayList<ResolvedType>(); |
| Set<String> visited = new HashSet<String>(); |
| recurseHierarchy(visited, types, this, includeITDs, allowMissing, genericsAware); |
| return types; |
| } |
| |
| private void addAndRecurse(Set<String> knowninterfaces, List<ResolvedMember> collector, ResolvedType resolvedType, |
| boolean includeITDs, boolean allowMissing, boolean genericsAware) { |
| // Add the methods declared on this type |
| collector.addAll(Arrays.asList(resolvedType.getDeclaredMethods())); |
| // now add all the inter-typed members too |
| if (includeITDs && resolvedType.interTypeMungers != null) { |
| for (ConcreteTypeMunger typeTransformer : interTypeMungers) { |
| ResolvedMember rm = typeTransformer.getSignature(); |
| if (rm != null) { // new parent type munger can have null signature |
| collector.add(typeTransformer.getSignature()); |
| } |
| } |
| } |
| // BUG? interface type superclass is Object - is that correct? |
| if (!resolvedType.isInterface() && !resolvedType.equals(ResolvedType.OBJECT)) { |
| ResolvedType superType = resolvedType.getSuperclass(); |
| if (superType != null && !superType.isMissing()) { |
| if (!genericsAware && superType.isParameterizedOrGenericType()) { |
| superType = superType.getRawType(); |
| } |
| // Recurse if we are not at the top |
| addAndRecurse(knowninterfaces, collector, superType, includeITDs, allowMissing, genericsAware); |
| } |
| } |
| // Go through the interfaces on the way back down |
| ResolvedType[] interfaces = resolvedType.getDeclaredInterfaces(); |
| for (int i = 0; i < interfaces.length; i++) { |
| ResolvedType iface = interfaces[i]; |
| if (!genericsAware && iface.isParameterizedOrGenericType()) { |
| iface = iface.getRawType(); |
| } |
| // 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 < resolvedType.interTypeMungers.size(); j++) { |
| ConcreteTypeMunger munger = resolvedType.interTypeMungers.get(j); |
| if (munger.getMunger() != null && munger.getMunger().getKind() == ResolvedTypeMunger.Parent |
| && ((NewParentTypeMunger) munger.getMunger()).getNewParent().equals(iface) // pr171953 |
| ) { |
| shouldSkip = true; |
| break; |
| } |
| } |
| |
| // Do not do interfaces more than once |
| if (!shouldSkip && !knowninterfaces.contains(iface.getSignature())) { |
| knowninterfaces.add(iface.getSignature()); |
| if (allowMissing && iface.isMissing()) { |
| if (iface instanceof MissingResolvedTypeWithKnownSignature) { |
| ((MissingResolvedTypeWithKnownSignature) iface).raiseWarningOnMissingInterfaceWhilstFindingMethods(); |
| } |
| } else { |
| addAndRecurse(knowninterfaces, collector, iface, includeITDs, allowMissing, genericsAware); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Recurse up a type hierarchy, first the superclasses then the super interfaces. |
| */ |
| private void recurseHierarchy(Set<String> knowninterfaces, List<ResolvedType> collector, ResolvedType resolvedType, |
| boolean includeITDs, boolean allowMissing, boolean genericsAware) { |
| collector.add(resolvedType); |
| if (!resolvedType.isInterface() && !resolvedType.equals(ResolvedType.OBJECT)) { |
| ResolvedType superType = resolvedType.getSuperclass(); |
| if (superType != null && !superType.isMissing()) { |
| if (!genericsAware && (superType.isParameterizedType() || superType.isGenericType())) { |
| superType = superType.getRawType(); |
| } |
| // Recurse if we are not at the top |
| recurseHierarchy(knowninterfaces, collector, superType, includeITDs, allowMissing, genericsAware); |
| } |
| } |
| // Go through the interfaces on the way back down |
| ResolvedType[] interfaces = resolvedType.getDeclaredInterfaces(); |
| for (int i = 0; i < interfaces.length; i++) { |
| ResolvedType iface = interfaces[i]; |
| if (!genericsAware && (iface.isParameterizedType() || iface.isGenericType())) { |
| iface = iface.getRawType(); |
| } |
| // 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 < resolvedType.interTypeMungers.size(); j++) { |
| ConcreteTypeMunger munger = resolvedType.interTypeMungers.get(j); |
| if (munger.getMunger() != null && munger.getMunger().getKind() == ResolvedTypeMunger.Parent |
| && ((NewParentTypeMunger) munger.getMunger()).getNewParent().equals(iface) // pr171953 |
| ) { |
| shouldSkip = true; |
| break; |
| } |
| } |
| |
| // Do not do interfaces more than once |
| if (!shouldSkip && !knowninterfaces.contains(iface.getSignature())) { |
| knowninterfaces.add(iface.getSignature()); |
| if (allowMissing && iface.isMissing()) { |
| if (iface instanceof MissingResolvedTypeWithKnownSignature) { |
| ((MissingResolvedTypeWithKnownSignature) iface).raiseWarningOnMissingInterfaceWhilstFindingMethods(); |
| } |
| } else { |
| recurseHierarchy(knowninterfaces, collector, iface, includeITDs, allowMissing, genericsAware); |
| } |
| } |
| } |
| } |
| |
| 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 field) { |
| Iterator<ResolvedMember> i = getFields(); |
| while (i.hasNext()) { |
| ResolvedMember resolvedMember = i.next(); |
| if (matches(resolvedMember, field)) { |
| return resolvedMember; |
| } |
| if (resolvedMember.hasBackingGenericMember() && field.getName().equals(resolvedMember.getName())) { |
| // might be worth checking the member behind the parameterized member (see pr137496) |
| if (matches(resolvedMember.getBackingGenericMember(), field)) { |
| return resolvedMember; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * described in JVM spec 2ed 5.4.3.3. Doesnt check ITDs. |
| * |
| * <p> |
| * Check the current type for the method. If it is not found, check the super class and any super interfaces. Taking care not to |
| * process interfaces multiple times. |
| */ |
| public ResolvedMember lookupMethod(Member m) { |
| List<ResolvedType> typesTolookat = new ArrayList<ResolvedType>(); |
| typesTolookat.add(this); |
| int pos = 0; |
| while (pos < typesTolookat.size()) { |
| ResolvedType type = typesTolookat.get(pos++); |
| if (!type.isMissing()) { |
| ResolvedMember[] methods = type.getDeclaredMethods(); |
| if (methods != null) { |
| for (int i = 0; i < methods.length; i++) { |
| ResolvedMember method = methods[i]; |
| if (matches(method, m)) { |
| return method; |
| } |
| // might be worth checking the method behind the parameterized method (137496) |
| if (method.hasBackingGenericMember() && m.getName().equals(method.getName())) { |
| if (matches(method.getBackingGenericMember(), m)) { |
| return method; |
| } |
| } |
| } |
| } |
| } |
| // Queue the superclass: |
| ResolvedType superclass = type.getSuperclass(); |
| if (superclass != null) { |
| typesTolookat.add(superclass); |
| } |
| // Queue any interfaces not already checked: |
| ResolvedType[] superinterfaces = type.getDeclaredInterfaces(); |
| if (superinterfaces != null) { |
| for (int i = 0; i < superinterfaces.length; i++) { |
| ResolvedType interf = superinterfaces[i]; |
| if (!typesTolookat.contains(interf)) { |
| typesTolookat.add(interf); |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * @param member the member to lookup in intertype declarations affecting this type |
| * @return the real signature defined by any matching intertype declaration, otherwise null |
| */ |
| public ResolvedMember lookupMethodInITDs(Member member) { |
| for (ConcreteTypeMunger typeTransformer : interTypeMungers) { |
| if (matches(typeTransformer.getSignature(), member)) { |
| return typeTransformer.getSignature(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * 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; |
| } |
| } |
| return null; |
| } |
| |
| // Bug (1) Do callers expect ITDs to be involved in the lookup? or do they do their own walk over ITDs? |
| /** |
| * 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, boolean eraseGenerics) { |
| Iterator<ResolvedMember> toSearch = null; |
| ResolvedMember found = null; |
| if ((aMember.getKind() == Member.METHOD) || (aMember.getKind() == Member.CONSTRUCTOR)) { |
| // toSearch = getMethodsWithoutIterator(true, allowMissing, !eraseGenerics).iterator(); |
| toSearch = getMethodsIncludingIntertypeDeclarations(!eraseGenerics, true); |
| } else if (aMember.getKind()==Member.ADVICE) { |
| return null; |
| } else { |
| assert aMember.getKind() == Member.FIELD; |
| toSearch = getFields(); |
| } |
| while (toSearch.hasNext()) { |
| ResolvedMember candidate = toSearch.next(); |
| if (eraseGenerics) { |
| if (candidate.hasBackingGenericMember()) { |
| candidate = candidate.getBackingGenericMember(); |
| } |
| } |
| // OPTIMIZE speed up matches? optimize order of checks |
| if (candidate.matches(aMember, eraseGenerics)) { |
| 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) { |
| return conflictingSignature(m1,m2,true); |
| } |
| |
| /** |
| * Do the two members conflict? Due to the change in 1.7.1, field itds on interfaces now act like 'default' fields - so types implementing |
| * those fields get the field if they don't have it already, otherwise they keep what they have. The conflict detection below had to be |
| * altered. Previously (<1.7.1) it is not a conflict if the declaring types are different. With v2itds it may still be a conflict if the |
| * declaring types are different. |
| */ |
| public static boolean conflictingSignature(Member m1, Member m2, boolean v2itds) { |
| 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) { |
| if (v2itds) { |
| if (m1.getDeclaringType().equals(m2.getDeclaringType())) { |
| return true; |
| } |
| } else { |
| 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<ResolvedMember> getPointcuts() { |
| final Iterators.Filter<ResolvedType> dupFilter = Iterators.dupFilter(); |
| // same order as fields |
| Iterators.Getter<ResolvedType, ResolvedType> typeGetter = new Iterators.Getter<ResolvedType, ResolvedType>() { |
| public Iterator<ResolvedType> get(ResolvedType o) { |
| return dupFilter.filter(o.getDirectSupertypes()); |
| } |
| }; |
| return Iterators.mapOver(Iterators.recur(this, typeGetter), PointcutGetterInstance); |
| } |
| |
| public ResolvedPointcutDefinition findPointcut(String name) { |
| for (Iterator<ResolvedMember> i = getPointcuts(); i.hasNext();) { |
| ResolvedPointcutDefinition f = (ResolvedPointcutDefinition) i.next(); |
| // the ResolvedPointcutDefinition can be null if there are other problems that prevented its resolution |
| if (f != null && 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); |
| if (getPerClause() == null) { |
| return crosscuttingMembers; |
| } |
| crosscuttingMembers.setPerClause(getPerClause()); |
| crosscuttingMembers.addShadowMungers(collectShadowMungers()); |
| // GENERICITDFIX |
| // 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()); |
| return crosscuttingMembers; |
| } |
| |
| public final List<Declare> collectDeclares(boolean includeAdviceLike) { |
| if (!this.isAspect()) { |
| return Collections.emptyList(); |
| } |
| |
| List<Declare> ret = new ArrayList<Declare>(); |
| // 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()); |
| final Iterators.Filter<ResolvedType> dupFilter = Iterators.dupFilter(); |
| Iterators.Getter<ResolvedType, ResolvedType> typeGetter = new Iterators.Getter<ResolvedType, ResolvedType>() { |
| public Iterator<ResolvedType> get(ResolvedType o) { |
| return dupFilter.filter((o).getDirectSupertypes()); |
| } |
| }; |
| Iterator<ResolvedType> typeIterator = Iterators.recur(this, typeGetter); |
| |
| while (typeIterator.hasNext()) { |
| ResolvedType ty = typeIterator.next(); |
| // System.out.println("super: " + ty + ", " + ); |
| for (Iterator<Declare> i = ty.getDeclares().iterator(); i.hasNext();) { |
| Declare dec = i.next(); |
| if (dec.isAdviceLike()) { |
| if (includeAdviceLike) { |
| ret.add(dec); |
| } |
| } else { |
| ret.add(dec); |
| } |
| } |
| } |
| } |
| |
| return ret; |
| } |
| |
| private final List<ShadowMunger> collectShadowMungers() { |
| if (!this.isAspect() || this.isAbstract() || this.doesNotExposeShadowMungers()) { |
| return Collections.emptyList(); |
| } |
| |
| List<ShadowMunger> acc = new ArrayList<ShadowMunger>(); |
| final Iterators.Filter<ResolvedType> dupFilter = Iterators.dupFilter(); |
| Iterators.Getter<ResolvedType, ResolvedType> typeGetter = new Iterators.Getter<ResolvedType, ResolvedType>() { |
| public Iterator<ResolvedType> get(ResolvedType o) { |
| return dupFilter.filter((o).getDirectSupertypes()); |
| } |
| }; |
| Iterator<ResolvedType> typeIterator = Iterators.recur(this, typeGetter); |
| |
| while (typeIterator.hasNext()) { |
| ResolvedType ty = typeIterator.next(); |
| acc.addAll(ty.getDeclaredShadowMungers()); |
| } |
| |
| return acc; |
| } |
| |
| public void addParent(ResolvedType newParent) { |
| // Nothing to do for anything except a ReferenceType |
| } |
| |
| protected boolean doesNotExposeShadowMungers() { |
| return false; |
| } |
| |
| public PerClause getPerClause() { |
| return null; |
| } |
| |
| public Collection<Declare> getDeclares() { |
| return Collections.emptyList(); |
| } |
| |
| public Collection<ConcreteTypeMunger> getTypeMungers() { |
| return Collections.emptyList(); |
| } |
| |
| public Collection<ResolvedMember> getPrivilegedAccesses() { |
| return Collections.emptyList(); |
| } |
| |
| // ---- 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 ResolvedType getOuterClass() { |
| return null; |
| } |
| |
| public void addAnnotation(AnnotationAJ annotationX) { |
| throw new RuntimeException("ResolvedType.addAnnotation() should never be called"); |
| } |
| |
| public AnnotationAJ[] getAnnotations() { |
| throw new RuntimeException("ResolvedType.getAnnotations() should never be called"); |
| } |
| |
| public boolean hasAnnotations() { |
| 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<String, UnresolvedType> getMemberParameterizationMap() { |
| if (!isParameterizedType()) { |
| return Collections.emptyMap(); |
| } |
| TypeVariable[] tvs = getGenericType().getTypeVariables(); |
| Map<String, UnresolvedType> parameterizationMap = new HashMap<String, UnresolvedType>(); |
| for (int i = 0; i < tvs.length; i++) { |
| parameterizationMap.put(tvs[i].getName(), typeParameters[i]); |
| } |
| return parameterizationMap; |
| } |
| |
| public List<ShadowMunger> getDeclaredAdvice() { |
| List<ShadowMunger> l = new ArrayList<ShadowMunger>(); |
| ResolvedMember[] methods = getDeclaredMethods(); |
| if (isParameterizedType()) { |
| methods = getGenericType().getDeclaredMethods(); |
| } |
| Map<String, UnresolvedType> 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] = 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 List<ShadowMunger> getDeclaredShadowMungers() { |
| return getDeclaredAdvice(); |
| } |
| |
| // ---- only for testing! |
| |
| public ResolvedMember[] getDeclaredJavaFields() { |
| return filterInJavaVisible(getDeclaredFields()); |
| } |
| |
| public ResolvedMember[] getDeclaredJavaMethods() { |
| return filterInJavaVisible(getDeclaredMethods()); |
| } |
| |
| private ResolvedMember[] filterInJavaVisible(ResolvedMember[] ms) { |
| List<ResolvedMember> l = new ArrayList<ResolvedMember>(); |
| for (int i = 0, len = ms.length; i < len; i++) { |
| if (!ms[i].isAjSynthetic() && ms[i].getAssociatedShadowMunger() == null) { |
| l.add(ms[i]); |
| } |
| } |
| return l.toArray(new ResolvedMember[l.size()]); |
| } |
| |
| public abstract ISourceContext getSourceContext(); |
| |
| // ---- fields |
| |
| public static final ResolvedType[] NONE = new ResolvedType[0]; |
| public static final ResolvedType[] EMPTY_ARRAY = NONE; |
| |
| public static final Missing MISSING = new Missing(); |
| |
| // ---- 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 final int size; |
| private final int index; |
| |
| Primitive(String signature, int size, int index) { |
| super(signature, null); |
| this.size = size; |
| this.index = index; |
| this.typeKind = TypeKind.PRIMITIVE; |
| } |
| |
| @Override |
| public final int getSize() { |
| return size; |
| } |
| |
| @Override |
| public final int getModifiers() { |
| return Modifier.PUBLIC | Modifier.FINAL; |
| } |
| |
| @Override |
| public final boolean isPrimitiveType() { |
| return true; |
| } |
| |
| public boolean hasAnnotation(UnresolvedType ofType) { |
| return false; |
| } |
| |
| @Override |
| 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]; |
| } |
| |
| @Override |
| public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) { |
| return isAssignableFrom(other); |
| } |
| |
| @Override |
| 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; |
| } |
| |
| @Override |
| public ResolvedType resolve(World world) { |
| if (this.world != world) { |
| throw new IllegalStateException(); |
| } |
| this.world = world; |
| return super.resolve(world); |
| } |
| |
| @Override |
| 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 |
| }; |
| |
| // ---- |
| |
| @Override |
| public final ResolvedMember[] getDeclaredFields() { |
| return ResolvedMember.NONE; |
| } |
| |
| @Override |
| public final ResolvedMember[] getDeclaredMethods() { |
| return ResolvedMember.NONE; |
| } |
| |
| @Override |
| public final ResolvedType[] getDeclaredInterfaces() { |
| return ResolvedType.NONE; |
| } |
| |
| @Override |
| public final ResolvedMember[] getDeclaredPointcuts() { |
| return ResolvedMember.NONE; |
| } |
| |
| @Override |
| public final ResolvedType getSuperclass() { |
| return null; |
| } |
| |
| @Override |
| public ISourceContext getSourceContext() { |
| return null; |
| } |
| |
| } |
| |
| static class Missing extends ResolvedType { |
| Missing() { |
| super(MISSING_NAME, null); |
| } |
| |
| // public final String toString() { |
| // return "<missing>"; |
| // } |
| @Override |
| public final String getName() { |
| return MISSING_NAME; |
| } |
| |
| @Override |
| public final boolean isMissing() { |
| return true; |
| } |
| |
| public boolean hasAnnotation(UnresolvedType ofType) { |
| return false; |
| } |
| |
| @Override |
| public final ResolvedMember[] getDeclaredFields() { |
| return ResolvedMember.NONE; |
| } |
| |
| @Override |
| public final ResolvedMember[] getDeclaredMethods() { |
| return ResolvedMember.NONE; |
| } |
| |
| @Override |
| public final ResolvedType[] getDeclaredInterfaces() { |
| return ResolvedType.NONE; |
| } |
| |
| @Override |
| public final ResolvedMember[] getDeclaredPointcuts() { |
| return ResolvedMember.NONE; |
| } |
| |
| @Override |
| public final ResolvedType getSuperclass() { |
| return null; |
| } |
| |
| @Override |
| public final int getModifiers() { |
| return 0; |
| } |
| |
| @Override |
| public final boolean isAssignableFrom(ResolvedType other) { |
| return false; |
| } |
| |
| @Override |
| public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) { |
| return false; |
| } |
| |
| @Override |
| public final boolean isCoerceableFrom(ResolvedType other) { |
| return false; |
| } |
| |
| @Override |
| public boolean needsNoConversionFrom(ResolvedType other) { |
| return false; |
| } |
| |
| @Override |
| public ISourceContext getSourceContext() { |
| return null; |
| } |
| |
| } |
| |
| /** |
| * 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) { |
| for (ConcreteTypeMunger tm : interTypeMungers) { |
| if (matches(tm.getSignature(), member)) { |
| return tm.getSignature(); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| public ResolvedMember lookupMemberWithSupersAndITDs(Member member) { |
| ResolvedMember ret = lookupMemberNoSupers(member); |
| if (ret != null) { |
| return ret; |
| } |
| |
| ResolvedType supert = getSuperclass(); |
| while (ret == null && supert != null) { |
| ret = supert.lookupMemberNoSupers(member); |
| if (ret == null) { |
| supert = supert.getSuperclass(); |
| } |
| } |
| |
| return ret; |
| } |
| |
| /** |
| * as lookupMemberNoSupers, but does not include ITDs |
| * |
| * @param member |
| * @return |
| */ |
| public ResolvedMember lookupDirectlyDeclaredMemberNoSupers(Member member) { |
| ResolvedMember ret; |
| if (member.getKind() == Member.FIELD) { |
| ret = lookupMember(member, getDeclaredFields()); |
| } else { |
| // assert member.getKind() == Member.METHOD || member.getKind() == |
| // Member.CONSTRUCTOR |
| ret = lookupMember(member, getDeclaredMethods()); |
| } |
| 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. |
| * |
| * @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) { |
| return ret; |
| } else { |
| ResolvedType superType = onType.getSuperclass(); |
| if (superType != null) { |
| 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; |
| } |
| } |
| } |
| } |
| return ret; |
| } |
| |
| protected List<ConcreteTypeMunger> interTypeMungers = new ArrayList<ConcreteTypeMunger>(); |
| |
| public List<ConcreteTypeMunger> getInterTypeMungers() { |
| return interTypeMungers; |
| } |
| |
| public List<ConcreteTypeMunger> getInterTypeParentMungers() { |
| List<ConcreteTypeMunger> l = new ArrayList<ConcreteTypeMunger>(); |
| for (ConcreteTypeMunger element : interTypeMungers) { |
| if (element.getMunger() instanceof NewParentTypeMunger) { |
| l.add(element); |
| } |
| } |
| return l; |
| } |
| |
| /** |
| * ??? This method is O(N*M) where N = number of methods and M is number of inter-type declarations in my super |
| */ |
| public List<ConcreteTypeMunger> getInterTypeMungersIncludingSupers() { |
| ArrayList<ConcreteTypeMunger> ret = new ArrayList<ConcreteTypeMunger>(); |
| collectInterTypeMungers(ret); |
| return ret; |
| } |
| |
| public List<ConcreteTypeMunger> getInterTypeParentMungersIncludingSupers() { |
| ArrayList<ConcreteTypeMunger> ret = new ArrayList<ConcreteTypeMunger>(); |
| collectInterTypeParentMungers(ret); |
| return ret; |
| } |
| |
| private void collectInterTypeParentMungers(List<ConcreteTypeMunger> collector) { |
| for (Iterator<ResolvedType> iter = getDirectSupertypes(); iter.hasNext();) { |
| ResolvedType superType = iter.next(); |
| superType.collectInterTypeParentMungers(collector); |
| } |
| collector.addAll(getInterTypeParentMungers()); |
| } |
| |
| protected void collectInterTypeMungers(List<ConcreteTypeMunger> collector) { |
| for (Iterator<ResolvedType> iter = getDirectSupertypes(); iter.hasNext();) { |
| ResolvedType superType = 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<ConcreteTypeMunger> iter1 = collector.iterator(); iter1.hasNext();) { |
| ConcreteTypeMunger superMunger = iter1.next(); |
| if (superMunger.getSignature() == null) { |
| continue; |
| } |
| |
| if (!superMunger.getSignature().isAbstract()) { |
| continue; |
| } |
| |
| for (ConcreteTypeMunger myMunger : getInterTypeMungers()) { |
| if (conflictingSignature(myMunger.getSignature(), superMunger.getSignature())) { |
| iter1.remove(); |
| continue outer; |
| } |
| } |
| |
| if (!superMunger.getSignature().isPublic()) { |
| continue; |
| } |
| |
| for (Iterator<ResolvedMember> iter = getMethods(true, true); iter.hasNext();) { |
| ResolvedMember method = 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 (ConcreteTypeMunger munger : getInterTypeMungersIncludingSupers()) { |
| itdProblem = checkAbstractDeclaration(munger) || itdProblem; // Rule 2 |
| } |
| |
| if (itdProblem) { |
| return; // If the rules above are broken, return right now |
| } |
| |
| for (ConcreteTypeMunger munger : getInterTypeMungersIncludingSupers()) { |
| if (munger.getSignature() != null && munger.getSignature().isAbstract() && munger.getMunger().getKind()!=ResolvedTypeMunger.PrivilegedAccess) { // Rule 1 |
| if (munger.getMunger().getKind() == ResolvedTypeMunger.MethodDelegate2) { |
| // 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; |
| } |
| } |
| 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 type, or null if it is not an nested type. |
| */ |
| public ResolvedType getDeclaringType() { |
| if (isArray()) { |
| return null; |
| } |
| if (isNested() || isAnonymous()) { |
| return getOuterClass(); |
| } |
| return null; |
| } |
| |
| public static boolean isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType) { |
| // System.err.println("mod: " + modifiers + ", " + targetType + " and " |
| // + fromType); |
| |
| if (Modifier.isPublic(modifiers)) { |
| return true; |
| } else if (Modifier.isPrivate(modifiers)) { |
| return targetType.getOutermostType().equals(fromType.getOutermostType()); |
| } else if (Modifier.isProtected(modifiers)) { |
| return samePackage(targetType, fromType) || targetType.isAssignableFrom(fromType); |
| } else { // package-visible |
| return samePackage(targetType, 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; |
| } |
| 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. |
| */ |
| 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; |
| 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 onTypeResolved = world.resolve(member.getDeclaringType()); |
| ResolvedType onType = onTypeResolved.getGenericType(); |
| if (onType == null) { |
| // The target is not generic |
| getWorld().getMessageHandler().handleMessage( |
| MessageUtil.error("The target type for the intertype declaration is not generic", |
| munger.getSourceLocation())); |
| return munger; |
| } |
| 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; |
| } |
| |
| /** |
| * Add an intertype munger to this type. isDuringCompilation tells us if we should be checking for an error scenario where two |
| * ITD fields are trying to use the same name. When this happens during compilation one of them is altered to get mangled name |
| * but when it happens during weaving it is too late and we need to put out an error asking them to recompile. |
| */ |
| public void addInterTypeMunger(ConcreteTypeMunger munger, boolean isDuringCompilation) { |
| ResolvedMember sig = munger.getSignature(); |
| bits = (bits & ~MungersAnalyzed); // clear the bit - as the mungers have changed |
| if (sig == null || munger.getMunger() == null || munger.getMunger().getKind() == ResolvedTypeMunger.PrivilegedAccess) { |
| interTypeMungers.add(munger); |
| return; |
| } |
| |
| // 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 |
| // is discovered and the tvar is collapsed to a bound? |
| munger = fillInAnyTypeParameters(munger); |
| sig = munger.getSignature(); // possibly changed when type parms filled in |
| |
| if (sig.getKind() == Member.METHOD) { |
| // OPTIMIZE can this be sped up? |
| if (clashesWithExistingMember(munger, getMethods(true, false))) { // ITDs checked below |
| return; |
| } |
| if (this.isInterface()) { |
| // OPTIMIZE this set of methods are always the same - must we keep creating them as a list? |
| if (clashesWithExistingMember(munger, Arrays.asList(world.getCoreType(OBJECT).getDeclaredMethods()).iterator())) { |
| return; |
| } |
| } |
| } else if (sig.getKind() == Member.FIELD) { |
| if (clashesWithExistingMember(munger, Arrays.asList(getDeclaredFields()).iterator())) { |
| return; |
| } |
| // Cannot cope with two version '2' style mungers for the same field on the same type |
| // Must error and request the user recompile at least one aspect with the |
| // -Xset:itdStyle=1 option |
| if (!isDuringCompilation) { |
| ResolvedTypeMunger thisRealMunger = munger.getMunger(); |
| if (thisRealMunger instanceof NewFieldTypeMunger) { |
| NewFieldTypeMunger newFieldTypeMunger = (NewFieldTypeMunger) thisRealMunger; |
| if (newFieldTypeMunger.version == NewFieldTypeMunger.VersionTwo) { |
| String thisRealMungerSignatureName = newFieldTypeMunger.getSignature().getName(); |
| for (ConcreteTypeMunger typeMunger : interTypeMungers) { |
| if (typeMunger.getMunger() instanceof NewFieldTypeMunger) { |
| if (typeMunger.getSignature().getKind() == Member.FIELD) { |
| NewFieldTypeMunger existing = (NewFieldTypeMunger) typeMunger.getMunger(); |
| if (existing.getSignature().getName().equals(thisRealMungerSignatureName) |
| && existing.version == NewFieldTypeMunger.VersionTwo |
| // this check ensures no problem for a clash with an ITD on an interface |
| && existing.getSignature().getDeclaringType() |
| .equals(newFieldTypeMunger.getSignature().getDeclaringType())) { |
| |
| // report error on the aspect |
| StringBuffer sb = new StringBuffer(); |
| sb.append("Cannot handle two aspects both attempting to use new style ITDs for the same named field "); |
| sb.append("on the same target type. Please recompile at least one aspect with '-Xset:itdVersion=1'."); |
| sb.append(" Aspects involved: " + munger.getAspectType().getName() + " and " |
| + typeMunger.getAspectType().getName() + "."); |
| sb.append(" Field is named '" + existing.getSignature().getName() + "'"); |
| getWorld().getMessageHandler().handleMessage( |
| new Message(sb.toString(), getSourceLocation(), true)); |
| return; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } else { |
| if (clashesWithExistingMember(munger, Arrays.asList(getDeclaredMethods()).iterator())) { |
| return; |
| } |
| } |
| |
| boolean needsAdding =true; |
| boolean needsToBeAddedEarlier =false; |
| // now compare to existingMungers |
| for (Iterator<ConcreteTypeMunger> i = interTypeMungers.iterator(); i.hasNext();) { |
| ConcreteTypeMunger existingMunger = i.next(); |
| boolean v2itds = munger.getSignature().getKind()== Member.FIELD && (munger.getMunger() instanceof NewFieldTypeMunger) && ((NewFieldTypeMunger)munger.getMunger()).version==NewFieldTypeMunger.VersionTwo; |
| |
| if (conflictingSignature(existingMunger.getSignature(), munger.getSignature(),v2itds)) { |
| // 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); |
| if (c < 0) { |
| // the existing munger dominates the new munger |
| checkLegalOverride(munger.getSignature(), existingMunger.getSignature(), 0x11, null); |
| needsAdding = false; |
| if (munger.getSignature().getKind()== Member.FIELD && munger.getSignature().getDeclaringType().resolve(world).isInterface() && ((NewFieldTypeMunger)munger.getMunger()).version==NewFieldTypeMunger.VersionTwo) { |
| // still need to add it |
| needsAdding=true; |
| } |
| break; |
| } else if (c > 0) { |
| // the new munger dominates the existing one |
| checkLegalOverride(existingMunger.getSignature(), munger.getSignature(), 0x11, null); |
| // i.remove(); |
| if (existingMunger.getSignature().getKind()==Member.FIELD && |
| existingMunger.getSignature().getDeclaringType().resolve(world).isInterface() |
| && ((NewFieldTypeMunger)existingMunger.getMunger()).version==NewFieldTypeMunger.VersionTwo) { |
| needsToBeAddedEarlier=true; |
| } else { |
| i.remove(); |
| } |
| break; |
| } else { |
| interTypeConflictError(munger, existingMunger); |
| interTypeConflictError(existingMunger, munger); |
| return; |
| } |
| } |
| } |
| } |
| // 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 |
| // signature for the ITD so it can be retrieved. |
| if (needsAdding) { |
| if (!needsToBeAddedEarlier) { |
| interTypeMungers.add(munger); |
| } else { |
| interTypeMungers.add(0,munger); |
| } |
| } |
| } |
| |
| /** |
| * Compare the type transformer with the existing members. A clash may not be an error (the ITD may be the 'default |
| * implementation') so returning false is not always a sign of an error. |
| * |
| * @return true if there is a clash |
| */ |
| private boolean clashesWithExistingMember(ConcreteTypeMunger typeTransformer, Iterator<ResolvedMember> existingMembers) { |
| ResolvedMember typeTransformerSignature = typeTransformer.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 |
| // } |
| ResolvedTypeMunger rtm = typeTransformer.getMunger(); |
| boolean v2itds = true; |
| if (rtm instanceof NewFieldTypeMunger && ((NewFieldTypeMunger)rtm).version==NewFieldTypeMunger.VersionOne) { |
| v2itds = false; |
| } |
| while (existingMembers.hasNext()) { |
| ResolvedMember existingMember = existingMembers.next(); |
| // don't worry about clashing with bridge methods |
| if (existingMember.isBridgeMethod()) { |
| continue; |
| } |
| if (conflictingSignature(existingMember, typeTransformerSignature,v2itds)) { |
| // System.err.println("conflict: existingMember=" + |
| // existingMember + " typeMunger=" + munger); |
| // System.err.println(munger.getSourceLocation() + ", " + |
| // munger.getSignature() + ", " + |
| // munger.getSignature().getSourceLocation()); |
| |
| if (isVisible(existingMember.getModifiers(), this, typeTransformer.getAspectType())) { |
| int c = compareMemberPrecedence(typeTransformerSignature, existingMember); |
| // System.err.println(" c: " + c); |
| if (c < 0) { |
| ResolvedType typeTransformerTargetType = typeTransformerSignature.getDeclaringType().resolve(world); |
| if (typeTransformerTargetType.isInterface()) { |
| ResolvedType existingMemberType = existingMember.getDeclaringType().resolve(world); |
| if ((rtm instanceof NewMethodTypeMunger) && !typeTransformerTargetType.equals(existingMemberType)) { |
| // Might be pr404601. ITD is on an interface with a different visibility to the real member |
| if (Modifier.isPrivate(typeTransformerSignature.getModifiers()) && |
| Modifier.isPublic(existingMember.getModifiers())) { |
| world.getMessageHandler().handleMessage(new Message("private intertype declaration '"+typeTransformerSignature.toString()+"' clashes with public member '"+existingMember.toString()+"'",existingMember.getSourceLocation(),true)); |
| } |
| } |
| } |
| // existingMember dominates munger |
| checkLegalOverride(typeTransformerSignature, existingMember, 0x10, typeTransformer.getAspectType()); |
| return true; |
| } else if (c > 0) { |
| // munger dominates existingMember |
| checkLegalOverride(existingMember, typeTransformerSignature, 0x01, typeTransformer.getAspectType()); |
| // 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(typeTransformerSignature.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<ConcreteTypeMunger> mungersAffectingThisType = wsi.getTypeMungers(declaringRt); |
| if (mungersAffectingThisType != null) { |
| for (Iterator<ConcreteTypeMunger> iterator = mungersAffectingThisType.iterator(); iterator |
| .hasNext() && !isDuplicateOfPreviousITD;) { |
| ConcreteTypeMunger ctMunger = 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(typeTransformer.getAspectType())) { |
| isDuplicateOfPreviousITD = true; |
| } |
| } |
| } |
| } |
| if (!isDuplicateOfPreviousITD) { |
| // b275032 - this is OK if it is the default ctor and that default ctor was generated |
| // at compile time, otherwise we cannot overwrite it |
| if (!(typeTransformerSignature.getName().equals("<init>") && existingMember.isDefaultConstructor())) { |
| String aspectName = typeTransformer.getAspectType().getName(); |
| ISourceLocation typeTransformerLocation = typeTransformer.getSourceLocation(); |
| ISourceLocation existingMemberLocation = existingMember.getSourceLocation(); |
| String msg = WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT, aspectName, |
| existingMember); |
| |
| // this isn't quite right really... as I think the errors should only be recorded against |
| // what is currently being processed or they may get lost or reported twice |
| |
| // report error on the aspect |
| getWorld().getMessageHandler().handleMessage(new Message(msg, typeTransformerLocation, true)); |
| |
| // report error on the affected type, if we can |
| if (existingMemberLocation != null) { |
| getWorld().getMessageHandler() |
| .handleMessage(new Message(msg, existingMemberLocation, true)); |
| } |
| return true; // clash - so ignore this itd |
| } |
| } |
| } |
| } |
| } else if (isDuplicateMemberWithinTargetType(existingMember, this, typeTransformerSignature)) { |
| getWorld().getMessageHandler().handleMessage( |
| MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT, typeTransformer |
| .getAspectType().getName(), existingMember), typeTransformer.getSourceLocation())); |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| // 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 (Modifier.isPrivate(itdMember.getModifiers())) { |
| 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; |
| } |
| |
| /** |
| * @param transformerPosition which parameter is the type transformer (0x10 for first, 0x01 for second, 0x11 for both, 0x00 for |
| * neither) |
| * @param aspectType the declaring type of aspect defining the *first* type transformer |
| * @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, int transformerPosition, ResolvedType aspectType) { |
| // System.err.println("check: " + child.getDeclaringType() + " overrides " + parent.getDeclaringType()); |
| if (Modifier.isFinal(parent.getModifiers())) { |
| // If the ITD matching is occurring due to pulling in a BinaryTypeBinding then this check can incorrectly |
| // signal an error because the ITD transformer being examined here will exactly match the member it added |
| // during the first round of compilation. This situation can only occur if the ITD is on an interface whilst |
| // the class is the top most implementor. If the ITD is on the same type that received it during compilation, |
| // this method won't be called as the previous check for precedence level will return 0. |
| |
| if (transformerPosition == 0x10 && aspectType != null) { |
| ResolvedType nonItdDeclaringType = child.getDeclaringType().resolve(world); |
| WeaverStateInfo wsi = nonItdDeclaringType.getWeaverState(); |
| if (wsi != null) { |
| List<ConcreteTypeMunger> transformersOnThisType = wsi.getTypeMungers(nonItdDeclaringType); |
| if (transformersOnThisType != null) { |
| for (ConcreteTypeMunger transformer : transformersOnThisType) { |
| // relatively crude check - is the ITD for the same as the existingmember |
| // and does it come from the same aspect |
| if (transformer.aspectType.equals(aspectType)) { |
| if (parent.equalsApartFromDeclaringType(transformer.getSignature())) { |
| return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| 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); |
| // } |
| } else { |
| ResolvedType rtParentReturnType = parent.resolve(world).getGenericReturnType().resolve(world); |
| ResolvedType rtChildReturnType = child.resolve(world).getGenericReturnType().resolve(world); |
| |
| incompatibleReturnTypes = !rtParentReturnType.equals(rtChildReturnType); |
| } |
| |
| if (incompatibleReturnTypes) { |
| 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), |
| child.getSourceLocation(), parent.getSourceLocation()); |
| return false; |
| } |
| } |
| // 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()); |
| 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; |
| } |
| |
| for (int j = 0, lenj = parentExceptions.length; j < lenj; j++) { |
| 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); |
| |
| return false; |
| } |
| boolean parentStatic = Modifier.isStatic(parent.getModifiers()); |
| boolean childStatic = Modifier.isStatic(child.getModifiers()); |
| if (parentStatic && !childStatic) { |
| world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_OVERRIDDEN_STATIC, child, parent), |
| child.getSourceLocation(), null); |
| return false; |
| } else if (childStatic && !parentStatic) { |
| 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; |
| |
| // 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 |
| // about what will have gotten through the compiler based on the normal |
| // java rules. clone goes against these... |
| if (Modifier.isProtected(m2.getModifiers()) && 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 (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 -1; |
| } |
| if (t2.isAssignableFrom(t1)) { |
| return +1; |
| } |
| 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); |
| } |
| throw new RuntimeException("bad modifier: " + m1); |
| } |
| |
| private static boolean isPackage(int i) { |
| 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; |
| /* |
| * if (m1.getMunger().getKind() == ResolvedTypeMunger.Field && m2.getMunger().getKind() == ResolvedTypeMunger.Field) { // if |
| * *exactly* the same, it's ok return true; } |
| */ |
| // 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()); |
| // return false; |
| } |
| |
| public ResolvedMember lookupSyntheticMember(Member member) { |
| // ??? horribly inefficient |
| // for (Iterator i = |
| // System.err.println("lookup " + member + " in " + interTypeMungers); |
| for (ConcreteTypeMunger m : interTypeMungers) { |
| ResolvedMember ret = m.getMatchingSyntheticMember(member); |
| if (ret != null) { |
| // 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, UnresolvedType.VOID, |
| "<init>", world.resolve(member.getParameterTypes())); |
| // Give the parameters names - they are going to be the dimensions uses to build the array (dim0 > dimN) |
| int count = ret.getParameterTypes().length; |
| String[] paramNames = new String[count]; |
| for (int i = 0; i < count; i++) { |
| paramNames[i] = new StringBuffer("dim").append(i).toString(); |
| } |
| ret.setParameterNames(paramNames); |
| return ret; |
| } |
| } |
| |
| // if (this.getSuperclass() != ResolvedType.OBJECT && |
| // this.getSuperclass() != null) { |
| // return getSuperclass().lookupSyntheticMember(member); |
| // } |
| |
| return null; |
| } |
| |
| static class SuperClassWalker implements Iterator<ResolvedType> { |
| |
| private ResolvedType curr; |
| private SuperInterfaceWalker iwalker; |
| private boolean wantGenerics; |
| |
| public SuperClassWalker(ResolvedType type, SuperInterfaceWalker iwalker, boolean genericsAware) { |
| this.curr = type; |
| this.iwalker = iwalker; |
| this.wantGenerics = genericsAware; |
| } |
| |
| public boolean hasNext() { |
| return curr != null; |
| } |
| |
| public ResolvedType next() { |
| ResolvedType ret = curr; |
| if (!wantGenerics && ret.isParameterizedOrGenericType()) { |
| ret = ret.getRawType(); |
| } |
| iwalker.push(ret); // tell the interface walker about another class whose interfaces need visiting |
| curr = curr.getSuperclass(); |
| return ret; |
| } |
| |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| |
| static class SuperInterfaceWalker implements Iterator<ResolvedType> { |
| |
| private Getter<ResolvedType, ResolvedType> ifaceGetter; |
| Iterator<ResolvedType> delegate = null; |
| public Queue<ResolvedType> toPersue = new LinkedList<ResolvedType>(); |
| public Set<ResolvedType> visited = new HashSet<ResolvedType>(); |
| |
| SuperInterfaceWalker(Iterators.Getter<ResolvedType, ResolvedType> ifaceGetter) { |
| this.ifaceGetter = ifaceGetter; |
| } |
| |
| SuperInterfaceWalker(Iterators.Getter<ResolvedType, ResolvedType> ifaceGetter, ResolvedType interfaceType) { |
| this.ifaceGetter = ifaceGetter; |
| this.delegate = Iterators.one(interfaceType); |
| } |
| |
| public boolean hasNext() { |
| if (delegate == null || !delegate.hasNext()) { |
| // either we set it up or we have run out, is there anything else to look at? |
| if (toPersue.isEmpty()) { |
| return false; |
| } |
| do { |
| ResolvedType next = toPersue.remove(); |
| visited.add(next); |
| delegate = ifaceGetter.get(next); // retrieve interfaces from a class or another interface |
| } while (!delegate.hasNext() && !toPersue.isEmpty()); |
| } |
| return delegate.hasNext(); |
| } |
| |
| public void push(ResolvedType ret) { |
| toPersue.add(ret); |
| } |
| |
| public ResolvedType next() { |
| ResolvedType next = delegate.next(); |
| // BUG should check for generics and erase? |
| // if (!visited.contains(next)) { |
| // visited.add(next); |
| if (visited.add(next)) { |
| toPersue.add(next); // pushes on interfaces already visited? |
| } |
| return next; |
| } |
| |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| |
| public void clearInterTypeMungers() { |
| if (isRawType()) { |
| ResolvedType genericType = getGenericType(); |
| if (genericType.isRawType()) { // ERROR SITUATION: PR341926 |
| // For some reason the raw type is pointing to another raw form (possibly itself) |
| System.err.println("DebugFor341926: Type " + this.getName() + " has an incorrect generic form"); |
| } else { |
| genericType.clearInterTypeMungers(); |
| } |
| } |
| // interTypeMungers.clear(); |
| // BUG? Why can't this be clear() instead: 293620 c6 |
| interTypeMungers = new ArrayList<ConcreteTypeMunger>(); |
| } |
| |
| public boolean isTopmostImplementor(ResolvedType interfaceType) { |
| boolean b = true; |
| if (isInterface()) { |
| b = false; |
| } else if (!interfaceType.isAssignableFrom(this, true)) { |
| b = false; |
| } else { |
| ResolvedType superclass = this.getSuperclass(); |
| if (superclass.isMissing()) { |
| b = true; // we don't know anything about supertype, and it can't be exposed to weaver |
| } else if (interfaceType.isAssignableFrom(superclass, true)) { // check that I'm truly the topmost implementor |
| b = false; |
| } |
| } |
| // System.out.println("is " + getName() + " topmostimplementor of " + interfaceType + "? " + b); |
| return b; |
| } |
| |
| public ResolvedType getTopmostImplementor(ResolvedType interfaceType) { |
| 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; |
| } |
| return this; |
| } |
| |
| public List<ResolvedMember> getExposedPointcuts() { |
| List<ResolvedMember> ret = new ArrayList<ResolvedMember>(); |
| if (getSuperclass() != null) { |
| ret.addAll(getSuperclass().getExposedPointcuts()); |
| } |
| |
| for (ResolvedType type : getDeclaredInterfaces()) { |
| addPointcutsResolvingConflicts(ret, Arrays.asList(type.getDeclaredPointcuts()), false); |
| } |
| |
| addPointcutsResolvingConflicts(ret, Arrays.asList(getDeclaredPointcuts()), true); |
| |
| for (ResolvedMember member : ret) { |
| ResolvedPointcutDefinition inherited = (ResolvedPointcutDefinition) member; |
| if (inherited != null && inherited.isAbstract()) { |
| if (!this.isAbstract()) { |
| getWorld().showMessage(IMessage.ERROR, |
| WeaverMessages.format(WeaverMessages.POINCUT_NOT_CONCRETE, inherited, this.getName()), |
| inherited.getSourceLocation(), this.getSourceLocation()); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| private void addPointcutsResolvingConflicts(List<ResolvedMember> acc, List<ResolvedMember> added, boolean isOverriding) { |
| for (Iterator<ResolvedMember> i = added.iterator(); i.hasNext();) { |
| ResolvedPointcutDefinition toAdd = (ResolvedPointcutDefinition) i.next(); |
| for (Iterator<ResolvedMember> j = acc.iterator(); j.hasNext();) { |
| ResolvedPointcutDefinition existing = (ResolvedPointcutDefinition) j.next(); |
| if (toAdd == null || existing == null || existing == toAdd) { |
| continue; |
| } |
| UnresolvedType pointcutDeclaringTypeUT = existing.getDeclaringType(); |
| if (pointcutDeclaringTypeUT != null) { |
| ResolvedType pointcutDeclaringType = pointcutDeclaringTypeUT.resolve(getWorld()); |
| if (!isVisible(existing.getModifiers(), pointcutDeclaringType, this)) { |
| // if they intended to override it but it is not visible, |
| // give them a nicer message |
| 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); |
| j.remove(); |
| } |
| continue; |
| } |
| } |
| if (conflictingSignature(existing, toAdd)) { |
| if (isOverriding) { |
| checkLegalOverride(existing, toAdd, 0x00, null); |
| j.remove(); |
| } else { |
| getWorld().showMessage( |
| 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 WeaverStateInfo getWeaverState() { |
| return null; |
| } |
| |
| /** |
| * Overridden by ReferenceType to return a sensible answer for parameterized and raw types. |
| * |
| * @return |
| */ |
| public ReferenceType getGenericType() { |
| // if (!(isParameterizedType() || isRawType())) |
| // throw new BCException("The type " + getBaseName() + " is not parameterized or raw - it has no generic type"); |
| return null; |
| } |
| |
| @Override |
| public ResolvedType getRawType() { |
| return super.getRawType().resolve(world); |
| } |
| |
| public ResolvedType parameterizedWith(UnresolvedType[] typeParameters) { |
| 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 (or nested parameterized types), |
| * return a version with those type parameters replaced in accordance with the passed bindings. |
| */ |
| @Override |
| public UnresolvedType parameterize(Map<String, UnresolvedType> typeBindings) { |
| if (!isParameterizedType()) { |
| // throw new IllegalStateException("Can't parameterize a type that is not a parameterized type"); |
| return this; |
| } |
| boolean workToDo = false; |
| for (int i = 0; i < typeParameters.length; i++) { |
| if (typeParameters[i].isTypeVariableReference() || (typeParameters[i] instanceof BoundedReferenceType) || typeParameters[i].isParameterizedType()) { |
| workToDo = true; |
| } |
| } |
| 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 = typeBindings.get(tvrt.getTypeVariable().getName()); |
| if (binding != null) { |
| newTypeParams[i] = binding; |
| } |
| } else if (newTypeParams[i] instanceof BoundedReferenceType) { |
| BoundedReferenceType brType = (BoundedReferenceType) newTypeParams[i]; |
| newTypeParams[i] = brType.parameterize(typeBindings); |
| // brType.parameterize(typeBindings) |
| } else if (newTypeParams[i].isParameterizedType()) { |
| newTypeParams[i] = newTypeParams[i].parameterize(typeBindings); |
| } |
| } |
| 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; |
| // } |
| // 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; |
| // List accumulatedTypes = new ArrayList(); |
| // 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); |
| // } |
| // if (forType.getSuperclass() != null) { |
| // accumulateParameterizedSuperTypes(forType.getSuperclass(), |
| // parameterizedTypeList); |
| // } |
| // ResolvedType[] interfaces = forType.getDeclaredInterfaces(); |
| // for (int i = 0; i < interfaces.length; i++) { |
| // accumulateParameterizedSuperTypes(interfaces[i], parameterizedTypeList); |
| // } |
| // } |
| /** |
| * @return true if assignable to java.lang.Exception |
| */ |
| public boolean isException() { |
| return (world.getCoreType(UnresolvedType.JL_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; |
| } |
| 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. |
| * |
| * @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); |
| } |
| |
| /** |
| * 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 |
| */ |
| 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> |
| * |
| * @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. |
| */ |
| public abstract boolean isCoerceableFrom(ResolvedType other); |
| |
| public boolean needsNoConversionFrom(ResolvedType 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) |
| } |
| |
| 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. |
| */ |
| public boolean isParameterizedWithTypeVariable() { |
| // MAYBE means we haven't worked it out yet... |
| if (parameterizedWithTypeVariable == FuzzyBoolean.MAYBE) { |
| |
| // if there are no type parameters then we cant be... |
| 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 |
| ) { |
| parameterizedWithTypeVariable = FuzzyBoolean.YES; |
| return true; |
| } |
| if (aType.isParameterizedType()) { |
| boolean b = aType.isParameterizedWithTypeVariable(); |
| if (b) { |
| parameterizedWithTypeVariable = FuzzyBoolean.YES; |
| return true; |
| } |
| } |
| if (aType.isGenericWildcard()) { |
| 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 = true; |
| } |
| if (b) { |
| parameterizedWithTypeVariable = FuzzyBoolean.YES; |
| return true; |
| } |
| // FIXME asc need to check additional interface bounds |
| } |
| if (boundedRT.isSuper()) { |
| 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 = true; |
| } |
| if (b) { |
| parameterizedWithTypeVariable = FuzzyBoolean.YES; |
| return true; |
| } |
| } |
| } |
| } |
| parameterizedWithTypeVariable = FuzzyBoolean.NO; |
| } |
| return parameterizedWithTypeVariable.alwaysTrue(); |
| } |
| |
| protected boolean ajMembersNeedParameterization() { |
| if (isParameterizedType()) { |
| return true; |
| } |
| ResolvedType superclass = getSuperclass(); |
| if (superclass != null && !superclass.isMissing()) { |
| return superclass.ajMembersNeedParameterization(); |
| } |
| return false; |
| } |
| |
| protected Map<String, UnresolvedType> getAjMemberParameterizationMap() { |
| Map<String, UnresolvedType> myMap = getMemberParameterizationMap(); |
| if (myMap.isEmpty()) { |
| // might extend a parameterized aspect that we also need to |
| // consider... |
| 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 |
| */ |
| public String getBinaryPath() { |
| return binaryPath; |
| } |
| |
| /** |
| * Undo any temporary modifications to the type (for example it may be holding annotations temporarily whilst some matching is |
| * occurring - These annotations will be added properly during weaving but sometimes for type completion they need to be held |
| * here for a while). |
| */ |
| public void ensureConsistent() { |
| // Nothing to do for anything except a ReferenceType |
| } |
| |
| /** |
| * For an annotation type, this will return if it is marked with @Inherited |
| */ |
| public boolean isInheritedAnnotation() { |
| ensureAnnotationBitsInitialized(); |
| return (bits & AnnotationMarkedInherited) != 0; |
| } |
| |
| /* |
| * Setup the bitflags if they have not already been done. |
| */ |
| private void ensureAnnotationBitsInitialized() { |
| if ((bits & AnnotationBitsInitialized) == 0) { |
| bits |= AnnotationBitsInitialized; |
| // Is it marked @Inherited? |
| if (hasAnnotation(UnresolvedType.AT_INHERITED)) { |
| bits |= AnnotationMarkedInherited; |
| } |
| } |
| } |
| |
| private boolean hasNewParentMungers() { |
| if ((bits & MungersAnalyzed) == 0) { |
| bits |= MungersAnalyzed; |
| for (ConcreteTypeMunger munger : interTypeMungers) { |
| ResolvedTypeMunger resolvedTypeMunger = munger.getMunger(); |
| if (resolvedTypeMunger != null && resolvedTypeMunger.getKind() == ResolvedTypeMunger.Parent) { |
| bits |= HasParentMunger; |
| } |
| } |
| } |
| return (bits & HasParentMunger) != 0; |
| } |
| |
| public void tagAsTypeHierarchyComplete() { |
| if (isParameterizedOrRawType()) { |
| ReferenceType genericType = this.getGenericType(); |
| genericType.tagAsTypeHierarchyComplete(); |
| return; |
| } |
| bits |= TypeHierarchyCompleteBit; |
| } |
| |
| public boolean isTypeHierarchyComplete() { |
| if (isParameterizedOrRawType()) { |
| return this.getGenericType().isTypeHierarchyComplete(); |
| } |
| return (bits & TypeHierarchyCompleteBit) != 0; |
| } |
| |
| /** |
| * return the weaver version used to build this type - defaults to the most recent version unless discovered otherwise. |
| * |
| * @return the (major) version, {@link WeaverVersionInfo} |
| */ |
| public int getCompilerVersion() { |
| return WeaverVersionInfo.getCurrentWeaverMajorVersion(); |
| } |
| |
| public boolean isPrimitiveArray() { |
| return false; |
| } |
| |
| public boolean isGroovyObject() { |
| if ((bits & GroovyObjectInitialized) == 0) { |
| ResolvedType[] intfaces = getDeclaredInterfaces(); |
| boolean done = false; |
| // TODO do we need to walk more of these? (i.e. the interfaces interfaces and supertypes supertype). Check what groovy |
| // does in the case where a hierarchy is involved and there are types in between GroovyObject/GroovyObjectSupport and |
| // the type |
| if (intfaces != null) { |
| for (ResolvedType intface : intfaces) { |
| if (intface.getName().equals("groovy.lang.GroovyObject")) { |
| bits |= IsGroovyObject; |
| done = true; |
| break; |
| } |
| } |
| } |
| if (!done) { |
| // take a look at the supertype |
| if (getSuperclass().getName().equals("groovy.lang.GroovyObjectSupport")) { |
| bits |= IsGroovyObject; |
| } |
| } |
| bits |= GroovyObjectInitialized; |
| } |
| return (bits & IsGroovyObject) != 0; |
| } |
| |
| } |